// $ANTLR 3.1.2 C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g 2009-05-21 01:17:54

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162
namespace GodPl.Parser
{

using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;

using IDictionary	= System.Collections.IDictionary;
using Hashtable 	= System.Collections.Hashtable;


using Antlr.Runtime.Tree;

public partial class GodPlGrammarParser : Parser
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"PROGRAM", 
		"GLOBALS", 
		"GLOBAL", 
		"INSTANCES", 
		"INSTANCE", 
		"FUNCTIONS", 
		"FUNCTION", 
		"DECLARATION", 
		"CODE", 
		"PARAMS", 
		"ARGS", 
		"UNARYMINUS", 
		"ARRAYACCESS", 
		"FUNCTIONACCESS", 
		"FIELDACCESS", 
		"EVENTS", 
		"EVENT", 
		"ACTIONS", 
		"NAME", 
		"TIMECOMP", 
		"TIMELIT", 
		"PARENTHESIZED", 
		"CONDITIONAL", 
		"NUMERICLIT", 
		"ASSIGN", 
		"PLUS", 
		"MINUS", 
		"TIMES", 
		"DIVIDE", 
		"MOD", 
		"LESS", 
		"GREATER", 
		"EQUAL", 
		"UNEQUAL", 
		"LEQUAL", 
		"GEQUAL", 
		"OR", 
		"AND", 
		"NOT", 
		"DOT", 
		"TRUE", 
		"FALSE", 
		"GAMETIME", 
		"EVERY", 
		"COLON", 
		"ROLL", 
		"PICKRANDOM", 
		"IMPLIES", 
		"VOID", 
		"UpperIdentifier", 
		"StringLiteral", 
		"TimeLiteral", 
		"DecimalLiteral", 
		"DecimalDigit", 
		"DoubleStringCharacter", 
		"EscapeSequence", 
		"CharacterEscapeSequence", 
		"SingleEscapeCharacter", 
		"NonEscapeCharacter", 
		"EscapeCharacter", 
		"Comment", 
		"LineComment", 
		"WhiteSpace", 
		"LowerIdentifier", 
		"'globals:'", 
		"'instances:'", 
		"'functions:'", 
		"'events:'", 
		"'float'", 
		"'string'", 
		"'('", 
		"')'", 
		"'{'", 
		"'}'", 
		"';'", 
		"','", 
		"'if'", 
		"'else if'", 
		"'else'", 
		"'while'", 
		"'foreach'", 
		"'break'", 
		"'return'", 
		"'['", 
		"']'"
    };

    public const int T__68 = 68;
    public const int FUNCTION = 10;
    public const int T__69 = 69;
    public const int TIMELIT = 24;
    public const int INSTANCES = 7;
    public const int FUNCTIONS = 9;
    public const int MOD = 33;
    public const int UNARYMINUS = 15;
    public const int LineComment = 65;
    public const int NOT = 42;
    public const int DecimalDigit = 57;
    public const int AND = 41;
    public const int EOF = -1;
    public const int DECLARATION = 11;
    public const int GAMETIME = 46;
    public const int NUMERICLIT = 27;
    public const int CODE = 12;
    public const int ACTIONS = 21;
    public const int PICKRANDOM = 50;
    public const int LEQUAL = 38;
    public const int NAME = 22;
    public const int GREATER = 35;
    public const int Comment = 64;
    public const int GEQUAL = 39;
    public const int SingleEscapeCharacter = 61;
    public const int EQUAL = 36;
    public const int PARENTHESIZED = 25;
    public const int LESS = 34;
    public const int ARGS = 14;
    public const int EscapeCharacter = 63;
    public const int PLUS = 29;
    public const int ARRAYACCESS = 16;
    public const int WhiteSpace = 66;
    public const int VOID = 52;
    public const int FUNCTIONACCESS = 17;
    public const int DOT = 43;
    public const int DIVIDE = 32;
    public const int PARAMS = 13;
    public const int GLOBALS = 5;
    public const int T__80 = 80;
    public const int IMPLIES = 51;
    public const int T__81 = 81;
    public const int T__82 = 82;
    public const int T__83 = 83;
    public const int TIMECOMP = 23;
    public const int ROLL = 49;
    public const int CONDITIONAL = 26;
    public const int TimeLiteral = 55;
    public const int EVERY = 47;
    public const int LowerIdentifier = 67;
    public const int DoubleStringCharacter = 58;
    public const int MINUS = 30;
    public const int T__85 = 85;
    public const int EVENT = 20;
    public const int DecimalLiteral = 56;
    public const int T__84 = 84;
    public const int TRUE = 44;
    public const int T__87 = 87;
    public const int EVENTS = 19;
    public const int T__86 = 86;
    public const int T__88 = 88;
    public const int UNEQUAL = 37;
    public const int StringLiteral = 54;
    public const int COLON = 48;
    public const int T__71 = 71;
    public const int FIELDACCESS = 18;
    public const int T__72 = 72;
    public const int T__70 = 70;
    public const int INSTANCE = 8;
    public const int OR = 40;
    public const int NonEscapeCharacter = 62;
    public const int ASSIGN = 28;
    public const int PROGRAM = 4;
    public const int UpperIdentifier = 53;
    public const int CharacterEscapeSequence = 60;
    public const int TIMES = 31;
    public const int T__76 = 76;
    public const int GLOBAL = 6;
    public const int FALSE = 45;
    public const int T__75 = 75;
    public const int T__74 = 74;
    public const int EscapeSequence = 59;
    public const int T__73 = 73;
    public const int T__79 = 79;
    public const int T__78 = 78;
    public const int T__77 = 77;

    // delegates
    // delegators



        public GodPlGrammarParser(ITokenStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public GodPlGrammarParser(ITokenStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();
            this.state.ruleMemo = new Hashtable[109+1];
             
             
        }
        
    protected ITreeAdaptor adaptor = new CommonTreeAdaptor();

    public ITreeAdaptor TreeAdaptor
    {
        get { return this.adaptor; }
        set {
    	this.adaptor = value;
    	}
    }

    override public string[] TokenNames {
		get { return GodPlGrammarParser.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g"; }
    }


    public class program_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "program"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:43:1: program : ( 'globals:' globals 'instances:' instances 'functions:' functionDefinitions 'events:' eventDefinitions ) -> ^( PROGRAM globals instances functionDefinitions eventDefinitions ) ;
    public GodPlGrammarParser.program_return program() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.program_return retval = new GodPlGrammarParser.program_return();
        retval.Start = input.LT(1);
        int program_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal1 = null;
        IToken string_literal3 = null;
        IToken string_literal5 = null;
        IToken string_literal7 = null;
        GodPlGrammarParser.globals_return globals2 = default(GodPlGrammarParser.globals_return);

        GodPlGrammarParser.instances_return instances4 = default(GodPlGrammarParser.instances_return);

        GodPlGrammarParser.functionDefinitions_return functionDefinitions6 = default(GodPlGrammarParser.functionDefinitions_return);

        GodPlGrammarParser.eventDefinitions_return eventDefinitions8 = default(GodPlGrammarParser.eventDefinitions_return);


        object string_literal1_tree=null;
        object string_literal3_tree=null;
        object string_literal5_tree=null;
        object string_literal7_tree=null;
        RewriteRuleTokenStream stream_69 = new RewriteRuleTokenStream(adaptor,"token 69");
        RewriteRuleTokenStream stream_68 = new RewriteRuleTokenStream(adaptor,"token 68");
        RewriteRuleTokenStream stream_70 = new RewriteRuleTokenStream(adaptor,"token 70");
        RewriteRuleTokenStream stream_71 = new RewriteRuleTokenStream(adaptor,"token 71");
        RewriteRuleSubtreeStream stream_globals = new RewriteRuleSubtreeStream(adaptor,"rule globals");
        RewriteRuleSubtreeStream stream_functionDefinitions = new RewriteRuleSubtreeStream(adaptor,"rule functionDefinitions");
        RewriteRuleSubtreeStream stream_instances = new RewriteRuleSubtreeStream(adaptor,"rule instances");
        RewriteRuleSubtreeStream stream_eventDefinitions = new RewriteRuleSubtreeStream(adaptor,"rule eventDefinitions");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 1) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:44:2: ( ( 'globals:' globals 'instances:' instances 'functions:' functionDefinitions 'events:' eventDefinitions ) -> ^( PROGRAM globals instances functionDefinitions eventDefinitions ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:44:4: ( 'globals:' globals 'instances:' instances 'functions:' functionDefinitions 'events:' eventDefinitions )
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:44:4: ( 'globals:' globals 'instances:' instances 'functions:' functionDefinitions 'events:' eventDefinitions )
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:44:5: 'globals:' globals 'instances:' instances 'functions:' functionDefinitions 'events:' eventDefinitions
            	{
            		string_literal1=(IToken)Match(input,68,FOLLOW_68_in_program173); if (state.failed) return retval; 
            		if ( (state.backtracking==0) ) stream_68.Add(string_literal1);

            		PushFollow(FOLLOW_globals_in_program177);
            		globals2 = globals();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( (state.backtracking==0) ) stream_globals.Add(globals2.Tree);
            		string_literal3=(IToken)Match(input,69,FOLLOW_69_in_program181); if (state.failed) return retval; 
            		if ( (state.backtracking==0) ) stream_69.Add(string_literal3);

            		PushFollow(FOLLOW_instances_in_program185);
            		instances4 = instances();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( (state.backtracking==0) ) stream_instances.Add(instances4.Tree);
            		string_literal5=(IToken)Match(input,70,FOLLOW_70_in_program189); if (state.failed) return retval; 
            		if ( (state.backtracking==0) ) stream_70.Add(string_literal5);

            		PushFollow(FOLLOW_functionDefinitions_in_program193);
            		functionDefinitions6 = functionDefinitions();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( (state.backtracking==0) ) stream_functionDefinitions.Add(functionDefinitions6.Tree);
            		string_literal7=(IToken)Match(input,71,FOLLOW_71_in_program197); if (state.failed) return retval; 
            		if ( (state.backtracking==0) ) stream_71.Add(string_literal7);

            		PushFollow(FOLLOW_eventDefinitions_in_program201);
            		eventDefinitions8 = eventDefinitions();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( (state.backtracking==0) ) stream_eventDefinitions.Add(eventDefinitions8.Tree);

            	}



            	// AST REWRITE
            	// elements:          globals, eventDefinitions, functionDefinitions, instances
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 52:3: -> ^( PROGRAM globals instances functionDefinitions eventDefinitions )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:52:6: ^( PROGRAM globals instances functionDefinitions eventDefinitions )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PROGRAM, "PROGRAM"), root_1);

            	    adaptor.AddChild(root_1, stream_globals.NextTree());
            	    adaptor.AddChild(root_1, stream_instances.NextTree());
            	    adaptor.AddChild(root_1, stream_functionDefinitions.NextTree());
            	    adaptor.AddChild(root_1, stream_eventDefinitions.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 1, program_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "program"

    public class typeSpecifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "typeSpecifier"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:84:1: typeSpecifier : ( primitiveType | objectCategory );
    public GodPlGrammarParser.typeSpecifier_return typeSpecifier() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.typeSpecifier_return retval = new GodPlGrammarParser.typeSpecifier_return();
        retval.Start = input.LT(1);
        int typeSpecifier_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.primitiveType_return primitiveType9 = default(GodPlGrammarParser.primitiveType_return);

        GodPlGrammarParser.objectCategory_return objectCategory10 = default(GodPlGrammarParser.objectCategory_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 2) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:85:2: ( primitiveType | objectCategory )
            int alt1 = 2;
            int LA1_0 = input.LA(1);

            if ( ((LA1_0 >= 72 && LA1_0 <= 73)) )
            {
                alt1 = 1;
            }
            else if ( (LA1_0 == UpperIdentifier) )
            {
                alt1 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d1s0 =
                    new NoViableAltException("", 1, 0, input);

                throw nvae_d1s0;
            }
            switch (alt1) 
            {
                case 1 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:85:4: primitiveType
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_primitiveType_in_typeSpecifier411);
                    	primitiveType9 = primitiveType();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, primitiveType9.Tree);

                    }
                    break;
                case 2 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:86:5: objectCategory
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_objectCategory_in_typeSpecifier417);
                    	objectCategory10 = objectCategory();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, objectCategory10.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 2, typeSpecifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "typeSpecifier"

    public class primitiveType_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "primitiveType"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:89:1: primitiveType : ( 'float' | 'string' );
    public GodPlGrammarParser.primitiveType_return primitiveType() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.primitiveType_return retval = new GodPlGrammarParser.primitiveType_return();
        retval.Start = input.LT(1);
        int primitiveType_StartIndex = input.Index();
        object root_0 = null;

        IToken set11 = null;

        object set11_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 3) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:90:2: ( 'float' | 'string' )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set11 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= 72 && input.LA(1) <= 73) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set11));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 3, primitiveType_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "primitiveType"

    public class objectCategory_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "objectCategory"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:94:1: objectCategory : UpperIdentifier ;
    public GodPlGrammarParser.objectCategory_return objectCategory() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.objectCategory_return retval = new GodPlGrammarParser.objectCategory_return();
        retval.Start = input.LT(1);
        int objectCategory_StartIndex = input.Index();
        object root_0 = null;

        IToken UpperIdentifier12 = null;

        object UpperIdentifier12_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 4) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:95:2: ( UpperIdentifier )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:95:4: UpperIdentifier
            {
            	root_0 = (object)adaptor.GetNilNode();

            	UpperIdentifier12=(IToken)Match(input,UpperIdentifier,FOLLOW_UpperIdentifier_in_objectCategory446); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{UpperIdentifier12_tree = (object)adaptor.Create(UpperIdentifier12);
            		adaptor.AddChild(root_0, UpperIdentifier12_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 4, objectCategory_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "objectCategory"

    public class globals_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "globals"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:98:1: globals : ( global )* -> ^( GLOBALS ( global )* ) ;
    public GodPlGrammarParser.globals_return globals() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.globals_return retval = new GodPlGrammarParser.globals_return();
        retval.Start = input.LT(1);
        int globals_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.global_return global13 = default(GodPlGrammarParser.global_return);


        RewriteRuleSubtreeStream stream_global = new RewriteRuleSubtreeStream(adaptor,"rule global");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 5) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:99:2: ( ( global )* -> ^( GLOBALS ( global )* ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:99:4: ( global )*
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:99:4: ( global )*
            	do 
            	{
            	    int alt2 = 2;
            	    int LA2_0 = input.LA(1);

            	    if ( (LA2_0 == UpperIdentifier || (LA2_0 >= 72 && LA2_0 <= 73)) )
            	    {
            	        alt2 = 1;
            	    }


            	    switch (alt2) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:0:0: global
            			    {
            			    	PushFollow(FOLLOW_global_in_globals457);
            			    	global13 = global();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_global.Add(global13.Tree);

            			    }
            			    break;

            			default:
            			    goto loop2;
            	    }
            	} while (true);

            	loop2:
            		;	// Stops C# compiler whining that label 'loop2' has no statements



            	// AST REWRITE
            	// elements:          global
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 99:12: -> ^( GLOBALS ( global )* )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:99:15: ^( GLOBALS ( global )* )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(GLOBALS, "GLOBALS"), root_1);

            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:99:25: ( global )*
            	    while ( stream_global.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_global.NextTree());

            	    }
            	    stream_global.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 5, globals_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "globals"

    public class global_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "global"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:103:1: global : tentativeInitialization -> ^( GLOBAL tentativeInitialization ) ;
    public GodPlGrammarParser.global_return global() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.global_return retval = new GodPlGrammarParser.global_return();
        retval.Start = input.LT(1);
        int global_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.tentativeInitialization_return tentativeInitialization14 = default(GodPlGrammarParser.tentativeInitialization_return);


        RewriteRuleSubtreeStream stream_tentativeInitialization = new RewriteRuleSubtreeStream(adaptor,"rule tentativeInitialization");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 6) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:104:2: ( tentativeInitialization -> ^( GLOBAL tentativeInitialization ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:104:4: tentativeInitialization
            {
            	PushFollow(FOLLOW_tentativeInitialization_in_global480);
            	tentativeInitialization14 = tentativeInitialization();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_tentativeInitialization.Add(tentativeInitialization14.Tree);


            	// AST REWRITE
            	// elements:          tentativeInitialization
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 104:28: -> ^( GLOBAL tentativeInitialization )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:104:31: ^( GLOBAL tentativeInitialization )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(GLOBAL, "GLOBAL"), root_1);

            	    adaptor.AddChild(root_1, stream_tentativeInitialization.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 6, global_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "global"

    public class instances_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "instances"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:107:1: instances : ( instance )* -> ^( INSTANCES ( instance )* ) ;
    public GodPlGrammarParser.instances_return instances() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.instances_return retval = new GodPlGrammarParser.instances_return();
        retval.Start = input.LT(1);
        int instances_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.instance_return instance15 = default(GodPlGrammarParser.instance_return);


        RewriteRuleSubtreeStream stream_instance = new RewriteRuleSubtreeStream(adaptor,"rule instance");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 7) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:108:2: ( ( instance )* -> ^( INSTANCES ( instance )* ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:108:4: ( instance )*
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:108:4: ( instance )*
            	do 
            	{
            	    int alt3 = 2;
            	    int LA3_0 = input.LA(1);

            	    if ( (LA3_0 == UpperIdentifier || (LA3_0 >= 72 && LA3_0 <= 73)) )
            	    {
            	        alt3 = 1;
            	    }


            	    switch (alt3) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:0:0: instance
            			    {
            			    	PushFollow(FOLLOW_instance_in_instances499);
            			    	instance15 = instance();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_instance.Add(instance15.Tree);

            			    }
            			    break;

            			default:
            			    goto loop3;
            	    }
            	} while (true);

            	loop3:
            		;	// Stops C# compiler whining that label 'loop3' has no statements



            	// AST REWRITE
            	// elements:          instance
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 108:14: -> ^( INSTANCES ( instance )* )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:108:17: ^( INSTANCES ( instance )* )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(INSTANCES, "INSTANCES"), root_1);

            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:108:29: ( instance )*
            	    while ( stream_instance.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_instance.NextTree());

            	    }
            	    stream_instance.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 7, instances_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "instances"

    public class instance_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "instance"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:112:1: instance : tentativeInitialization -> ^( INSTANCE tentativeInitialization ) ;
    public GodPlGrammarParser.instance_return instance() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.instance_return retval = new GodPlGrammarParser.instance_return();
        retval.Start = input.LT(1);
        int instance_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.tentativeInitialization_return tentativeInitialization16 = default(GodPlGrammarParser.tentativeInitialization_return);


        RewriteRuleSubtreeStream stream_tentativeInitialization = new RewriteRuleSubtreeStream(adaptor,"rule tentativeInitialization");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 8) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:113:2: ( tentativeInitialization -> ^( INSTANCE tentativeInitialization ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:113:4: tentativeInitialization
            {
            	PushFollow(FOLLOW_tentativeInitialization_in_instance522);
            	tentativeInitialization16 = tentativeInitialization();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_tentativeInitialization.Add(tentativeInitialization16.Tree);


            	// AST REWRITE
            	// elements:          tentativeInitialization
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 113:28: -> ^( INSTANCE tentativeInitialization )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:113:31: ^( INSTANCE tentativeInitialization )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(INSTANCE, "INSTANCE"), root_1);

            	    adaptor.AddChild(root_1, stream_tentativeInitialization.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 8, instance_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "instance"

    public class tentativeInitializations_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "tentativeInitializations"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:118:1: tentativeInitializations : ( tentativeInitialization )* ;
    public GodPlGrammarParser.tentativeInitializations_return tentativeInitializations() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.tentativeInitializations_return retval = new GodPlGrammarParser.tentativeInitializations_return();
        retval.Start = input.LT(1);
        int tentativeInitializations_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.tentativeInitialization_return tentativeInitialization17 = default(GodPlGrammarParser.tentativeInitialization_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 9) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:119:2: ( ( tentativeInitialization )* )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:119:4: ( tentativeInitialization )*
            {
            	root_0 = (object)adaptor.GetNilNode();

            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:119:4: ( tentativeInitialization )*
            	do 
            	{
            	    int alt4 = 2;
            	    int LA4_0 = input.LA(1);

            	    if ( (LA4_0 == UpperIdentifier || (LA4_0 >= 72 && LA4_0 <= 73)) )
            	    {
            	        alt4 = 1;
            	    }


            	    switch (alt4) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:0:0: tentativeInitialization
            			    {
            			    	PushFollow(FOLLOW_tentativeInitialization_in_tentativeInitializations545);
            			    	tentativeInitialization17 = tentativeInitialization();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, tentativeInitialization17.Tree);

            			    }
            			    break;

            			default:
            			    goto loop4;
            	    }
            	} while (true);

            	loop4:
            		;	// Stops C# compiler whining that label 'loop4' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 9, tentativeInitializations_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "tentativeInitializations"

    public class functionDefinitions_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "functionDefinitions"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:122:1: functionDefinitions : ( functionDefinition )* -> ^( FUNCTIONS ( functionDefinition )* ) ;
    public GodPlGrammarParser.functionDefinitions_return functionDefinitions() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.functionDefinitions_return retval = new GodPlGrammarParser.functionDefinitions_return();
        retval.Start = input.LT(1);
        int functionDefinitions_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.functionDefinition_return functionDefinition18 = default(GodPlGrammarParser.functionDefinition_return);


        RewriteRuleSubtreeStream stream_functionDefinition = new RewriteRuleSubtreeStream(adaptor,"rule functionDefinition");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 10) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:123:2: ( ( functionDefinition )* -> ^( FUNCTIONS ( functionDefinition )* ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:123:4: ( functionDefinition )*
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:123:4: ( functionDefinition )*
            	do 
            	{
            	    int alt5 = 2;
            	    int LA5_0 = input.LA(1);

            	    if ( ((LA5_0 >= VOID && LA5_0 <= UpperIdentifier) || (LA5_0 >= 72 && LA5_0 <= 73)) )
            	    {
            	        alt5 = 1;
            	    }


            	    switch (alt5) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:0:0: functionDefinition
            			    {
            			    	PushFollow(FOLLOW_functionDefinition_in_functionDefinitions558);
            			    	functionDefinition18 = functionDefinition();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_functionDefinition.Add(functionDefinition18.Tree);

            			    }
            			    break;

            			default:
            			    goto loop5;
            	    }
            	} while (true);

            	loop5:
            		;	// Stops C# compiler whining that label 'loop5' has no statements



            	// AST REWRITE
            	// elements:          functionDefinition
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 123:24: -> ^( FUNCTIONS ( functionDefinition )* )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:123:27: ^( FUNCTIONS ( functionDefinition )* )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(FUNCTIONS, "FUNCTIONS"), root_1);

            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:123:39: ( functionDefinition )*
            	    while ( stream_functionDefinition.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_functionDefinition.NextTree());

            	    }
            	    stream_functionDefinition.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 10, functionDefinitions_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "functionDefinitions"

    public class eventDefinitions_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "eventDefinitions"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:126:1: eventDefinitions : ( eventDefinition )* -> ^( EVENTS ( eventDefinition )* ) ;
    public GodPlGrammarParser.eventDefinitions_return eventDefinitions() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.eventDefinitions_return retval = new GodPlGrammarParser.eventDefinitions_return();
        retval.Start = input.LT(1);
        int eventDefinitions_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.eventDefinition_return eventDefinition19 = default(GodPlGrammarParser.eventDefinition_return);


        RewriteRuleSubtreeStream stream_eventDefinition = new RewriteRuleSubtreeStream(adaptor,"rule eventDefinition");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 11) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:127:2: ( ( eventDefinition )* -> ^( EVENTS ( eventDefinition )* ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:127:4: ( eventDefinition )*
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:127:4: ( eventDefinition )*
            	do 
            	{
            	    int alt6 = 2;
            	    int LA6_0 = input.LA(1);

            	    if ( (LA6_0 == 74) )
            	    {
            	        alt6 = 1;
            	    }


            	    switch (alt6) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:0:0: eventDefinition
            			    {
            			    	PushFollow(FOLLOW_eventDefinition_in_eventDefinitions580);
            			    	eventDefinition19 = eventDefinition();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_eventDefinition.Add(eventDefinition19.Tree);

            			    }
            			    break;

            			default:
            			    goto loop6;
            	    }
            	} while (true);

            	loop6:
            		;	// Stops C# compiler whining that label 'loop6' has no statements



            	// AST REWRITE
            	// elements:          eventDefinition
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 127:21: -> ^( EVENTS ( eventDefinition )* )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:127:24: ^( EVENTS ( eventDefinition )* )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(EVENTS, "EVENTS"), root_1);

            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:127:33: ( eventDefinition )*
            	    while ( stream_eventDefinition.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_eventDefinition.NextTree());

            	    }
            	    stream_eventDefinition.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 11, eventDefinitions_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "eventDefinitions"

    public class eventDefinition_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "eventDefinition"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:130:1: eventDefinition : '(' expression ')' IMPLIES '{' actions '}' -> ^( EVENT expression actions ) ;
    public GodPlGrammarParser.eventDefinition_return eventDefinition() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.eventDefinition_return retval = new GodPlGrammarParser.eventDefinition_return();
        retval.Start = input.LT(1);
        int eventDefinition_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal20 = null;
        IToken char_literal22 = null;
        IToken IMPLIES23 = null;
        IToken char_literal24 = null;
        IToken char_literal26 = null;
        GodPlGrammarParser.expression_return expression21 = default(GodPlGrammarParser.expression_return);

        GodPlGrammarParser.actions_return actions25 = default(GodPlGrammarParser.actions_return);


        object char_literal20_tree=null;
        object char_literal22_tree=null;
        object IMPLIES23_tree=null;
        object char_literal24_tree=null;
        object char_literal26_tree=null;
        RewriteRuleTokenStream stream_77 = new RewriteRuleTokenStream(adaptor,"token 77");
        RewriteRuleTokenStream stream_IMPLIES = new RewriteRuleTokenStream(adaptor,"token IMPLIES");
        RewriteRuleTokenStream stream_74 = new RewriteRuleTokenStream(adaptor,"token 74");
        RewriteRuleTokenStream stream_75 = new RewriteRuleTokenStream(adaptor,"token 75");
        RewriteRuleTokenStream stream_76 = new RewriteRuleTokenStream(adaptor,"token 76");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_actions = new RewriteRuleSubtreeStream(adaptor,"rule actions");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 12) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:131:2: ( '(' expression ')' IMPLIES '{' actions '}' -> ^( EVENT expression actions ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:131:4: '(' expression ')' IMPLIES '{' actions '}'
            {
            	char_literal20=(IToken)Match(input,74,FOLLOW_74_in_eventDefinition602); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_74.Add(char_literal20);

            	PushFollow(FOLLOW_expression_in_eventDefinition604);
            	expression21 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_expression.Add(expression21.Tree);
            	char_literal22=(IToken)Match(input,75,FOLLOW_75_in_eventDefinition606); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_75.Add(char_literal22);

            	IMPLIES23=(IToken)Match(input,IMPLIES,FOLLOW_IMPLIES_in_eventDefinition608); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_IMPLIES.Add(IMPLIES23);

            	char_literal24=(IToken)Match(input,76,FOLLOW_76_in_eventDefinition610); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_76.Add(char_literal24);

            	PushFollow(FOLLOW_actions_in_eventDefinition612);
            	actions25 = actions();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_actions.Add(actions25.Tree);
            	char_literal26=(IToken)Match(input,77,FOLLOW_77_in_eventDefinition614); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_77.Add(char_literal26);



            	// AST REWRITE
            	// elements:          actions, expression
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 131:47: -> ^( EVENT expression actions )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:131:50: ^( EVENT expression actions )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(EVENT, "EVENT"), root_1);

            	    adaptor.AddChild(root_1, stream_expression.NextTree());
            	    adaptor.AddChild(root_1, stream_actions.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 12, eventDefinition_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "eventDefinition"

    public class actions_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "actions"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:134:1: actions : ( action )* -> ^( ACTIONS ( action )* ) ;
    public GodPlGrammarParser.actions_return actions() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.actions_return retval = new GodPlGrammarParser.actions_return();
        retval.Start = input.LT(1);
        int actions_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.action_return action27 = default(GodPlGrammarParser.action_return);


        RewriteRuleSubtreeStream stream_action = new RewriteRuleSubtreeStream(adaptor,"rule action");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 13) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:135:2: ( ( action )* -> ^( ACTIONS ( action )* ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:135:4: ( action )*
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:135:4: ( action )*
            	do 
            	{
            	    int alt7 = 2;
            	    int LA7_0 = input.LA(1);

            	    if ( (LA7_0 == UpperIdentifier || LA7_0 == LowerIdentifier) )
            	    {
            	        alt7 = 1;
            	    }


            	    switch (alt7) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:0:0: action
            			    {
            			    	PushFollow(FOLLOW_action_in_actions637);
            			    	action27 = action();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_action.Add(action27.Tree);

            			    }
            			    break;

            			default:
            			    goto loop7;
            	    }
            	} while (true);

            	loop7:
            		;	// Stops C# compiler whining that label 'loop7' has no statements



            	// AST REWRITE
            	// elements:          action
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 135:12: -> ^( ACTIONS ( action )* )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:135:15: ^( ACTIONS ( action )* )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(ACTIONS, "ACTIONS"), root_1);

            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:135:25: ( action )*
            	    while ( stream_action.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_action.NextTree());

            	    }
            	    stream_action.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 13, actions_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "actions"

    public class action_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "action"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:137:1: action : functionName '(' argumentList ')' ';' -> ^( FUNCTIONACCESS functionName argumentList ) ;
    public GodPlGrammarParser.action_return action() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.action_return retval = new GodPlGrammarParser.action_return();
        retval.Start = input.LT(1);
        int action_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal29 = null;
        IToken char_literal31 = null;
        IToken char_literal32 = null;
        GodPlGrammarParser.functionName_return functionName28 = default(GodPlGrammarParser.functionName_return);

        GodPlGrammarParser.argumentList_return argumentList30 = default(GodPlGrammarParser.argumentList_return);


        object char_literal29_tree=null;
        object char_literal31_tree=null;
        object char_literal32_tree=null;
        RewriteRuleTokenStream stream_78 = new RewriteRuleTokenStream(adaptor,"token 78");
        RewriteRuleTokenStream stream_74 = new RewriteRuleTokenStream(adaptor,"token 74");
        RewriteRuleTokenStream stream_75 = new RewriteRuleTokenStream(adaptor,"token 75");
        RewriteRuleSubtreeStream stream_functionName = new RewriteRuleSubtreeStream(adaptor,"rule functionName");
        RewriteRuleSubtreeStream stream_argumentList = new RewriteRuleSubtreeStream(adaptor,"rule argumentList");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 14) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:138:2: ( functionName '(' argumentList ')' ';' -> ^( FUNCTIONACCESS functionName argumentList ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:138:4: functionName '(' argumentList ')' ';'
            {
            	PushFollow(FOLLOW_functionName_in_action658);
            	functionName28 = functionName();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_functionName.Add(functionName28.Tree);
            	char_literal29=(IToken)Match(input,74,FOLLOW_74_in_action660); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_74.Add(char_literal29);

            	PushFollow(FOLLOW_argumentList_in_action662);
            	argumentList30 = argumentList();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_argumentList.Add(argumentList30.Tree);
            	char_literal31=(IToken)Match(input,75,FOLLOW_75_in_action664); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_75.Add(char_literal31);

            	char_literal32=(IToken)Match(input,78,FOLLOW_78_in_action666); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_78.Add(char_literal32);



            	// AST REWRITE
            	// elements:          argumentList, functionName
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 138:42: -> ^( FUNCTIONACCESS functionName argumentList )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:138:45: ^( FUNCTIONACCESS functionName argumentList )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(FUNCTIONACCESS, "FUNCTIONACCESS"), root_1);

            	    adaptor.AddChild(root_1, stream_functionName.NextTree());
            	    adaptor.AddChild(root_1, stream_argumentList.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 14, action_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "action"

    public class functionDefinition_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "functionDefinition"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:141:1: functionDefinition : functionType functionName '(' formalParameterList ')' block -> ^( FUNCTION functionType ^( NAME functionName ) formalParameterList block ) ;
    public GodPlGrammarParser.functionDefinition_return functionDefinition() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.functionDefinition_return retval = new GodPlGrammarParser.functionDefinition_return();
        retval.Start = input.LT(1);
        int functionDefinition_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal35 = null;
        IToken char_literal37 = null;
        GodPlGrammarParser.functionType_return functionType33 = default(GodPlGrammarParser.functionType_return);

        GodPlGrammarParser.functionName_return functionName34 = default(GodPlGrammarParser.functionName_return);

        GodPlGrammarParser.formalParameterList_return formalParameterList36 = default(GodPlGrammarParser.formalParameterList_return);

        GodPlGrammarParser.block_return block38 = default(GodPlGrammarParser.block_return);


        object char_literal35_tree=null;
        object char_literal37_tree=null;
        RewriteRuleTokenStream stream_74 = new RewriteRuleTokenStream(adaptor,"token 74");
        RewriteRuleTokenStream stream_75 = new RewriteRuleTokenStream(adaptor,"token 75");
        RewriteRuleSubtreeStream stream_functionType = new RewriteRuleSubtreeStream(adaptor,"rule functionType");
        RewriteRuleSubtreeStream stream_block = new RewriteRuleSubtreeStream(adaptor,"rule block");
        RewriteRuleSubtreeStream stream_functionName = new RewriteRuleSubtreeStream(adaptor,"rule functionName");
        RewriteRuleSubtreeStream stream_formalParameterList = new RewriteRuleSubtreeStream(adaptor,"rule formalParameterList");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 15) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:142:2: ( functionType functionName '(' formalParameterList ')' block -> ^( FUNCTION functionType ^( NAME functionName ) formalParameterList block ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:142:4: functionType functionName '(' formalParameterList ')' block
            {
            	PushFollow(FOLLOW_functionType_in_functionDefinition687);
            	functionType33 = functionType();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_functionType.Add(functionType33.Tree);
            	PushFollow(FOLLOW_functionName_in_functionDefinition689);
            	functionName34 = functionName();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_functionName.Add(functionName34.Tree);
            	char_literal35=(IToken)Match(input,74,FOLLOW_74_in_functionDefinition691); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_74.Add(char_literal35);

            	PushFollow(FOLLOW_formalParameterList_in_functionDefinition693);
            	formalParameterList36 = formalParameterList();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_formalParameterList.Add(formalParameterList36.Tree);
            	char_literal37=(IToken)Match(input,75,FOLLOW_75_in_functionDefinition695); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_75.Add(char_literal37);

            	PushFollow(FOLLOW_block_in_functionDefinition697);
            	block38 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_block.Add(block38.Tree);


            	// AST REWRITE
            	// elements:          formalParameterList, functionType, functionName, block
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 142:64: -> ^( FUNCTION functionType ^( NAME functionName ) formalParameterList block )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:143:3: ^( FUNCTION functionType ^( NAME functionName ) formalParameterList block )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(FUNCTION, "FUNCTION"), root_1);

            	    adaptor.AddChild(root_1, stream_functionType.NextTree());
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:143:27: ^( NAME functionName )
            	    {
            	    object root_2 = (object)adaptor.GetNilNode();
            	    root_2 = (object)adaptor.BecomeRoot((object)adaptor.Create(NAME, "NAME"), root_2);

            	    adaptor.AddChild(root_2, stream_functionName.NextTree());

            	    adaptor.AddChild(root_1, root_2);
            	    }
            	    adaptor.AddChild(root_1, stream_formalParameterList.NextTree());
            	    adaptor.AddChild(root_1, stream_block.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 15, functionDefinition_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "functionDefinition"

    public class functionType_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "functionType"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:146:1: functionType : ( typeSpecifier | VOID );
    public GodPlGrammarParser.functionType_return functionType() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.functionType_return retval = new GodPlGrammarParser.functionType_return();
        retval.Start = input.LT(1);
        int functionType_StartIndex = input.Index();
        object root_0 = null;

        IToken VOID40 = null;
        GodPlGrammarParser.typeSpecifier_return typeSpecifier39 = default(GodPlGrammarParser.typeSpecifier_return);


        object VOID40_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 16) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:147:2: ( typeSpecifier | VOID )
            int alt8 = 2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0 == UpperIdentifier || (LA8_0 >= 72 && LA8_0 <= 73)) )
            {
                alt8 = 1;
            }
            else if ( (LA8_0 == VOID) )
            {
                alt8 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d8s0 =
                    new NoViableAltException("", 8, 0, input);

                throw nvae_d8s0;
            }
            switch (alt8) 
            {
                case 1 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:147:4: typeSpecifier
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_typeSpecifier_in_functionType730);
                    	typeSpecifier39 = typeSpecifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, typeSpecifier39.Tree);

                    }
                    break;
                case 2 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:148:4: VOID
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	VOID40=(IToken)Match(input,VOID,FOLLOW_VOID_in_functionType735); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{VOID40_tree = (object)adaptor.Create(VOID40);
                    		adaptor.AddChild(root_0, VOID40_tree);
                    	}

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 16, functionType_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "functionType"

    public class formalParameterList_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "formalParameterList"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:152:1: formalParameterList : ( variableDeclaration ( ',' variableDeclaration )* )? -> ^( PARAMS ( variableDeclaration )* ) ;
    public GodPlGrammarParser.formalParameterList_return formalParameterList() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.formalParameterList_return retval = new GodPlGrammarParser.formalParameterList_return();
        retval.Start = input.LT(1);
        int formalParameterList_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal42 = null;
        GodPlGrammarParser.variableDeclaration_return variableDeclaration41 = default(GodPlGrammarParser.variableDeclaration_return);

        GodPlGrammarParser.variableDeclaration_return variableDeclaration43 = default(GodPlGrammarParser.variableDeclaration_return);


        object char_literal42_tree=null;
        RewriteRuleTokenStream stream_79 = new RewriteRuleTokenStream(adaptor,"token 79");
        RewriteRuleSubtreeStream stream_variableDeclaration = new RewriteRuleSubtreeStream(adaptor,"rule variableDeclaration");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 17) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:153:2: ( ( variableDeclaration ( ',' variableDeclaration )* )? -> ^( PARAMS ( variableDeclaration )* ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:153:4: ( variableDeclaration ( ',' variableDeclaration )* )?
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:153:4: ( variableDeclaration ( ',' variableDeclaration )* )?
            	int alt10 = 2;
            	int LA10_0 = input.LA(1);

            	if ( (LA10_0 == UpperIdentifier || (LA10_0 >= 72 && LA10_0 <= 73)) )
            	{
            	    alt10 = 1;
            	}
            	switch (alt10) 
            	{
            	    case 1 :
            	        // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:153:5: variableDeclaration ( ',' variableDeclaration )*
            	        {
            	        	PushFollow(FOLLOW_variableDeclaration_in_formalParameterList749);
            	        	variableDeclaration41 = variableDeclaration();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( (state.backtracking==0) ) stream_variableDeclaration.Add(variableDeclaration41.Tree);
            	        	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:153:25: ( ',' variableDeclaration )*
            	        	do 
            	        	{
            	        	    int alt9 = 2;
            	        	    int LA9_0 = input.LA(1);

            	        	    if ( (LA9_0 == 79) )
            	        	    {
            	        	        alt9 = 1;
            	        	    }


            	        	    switch (alt9) 
            	        		{
            	        			case 1 :
            	        			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:153:26: ',' variableDeclaration
            	        			    {
            	        			    	char_literal42=(IToken)Match(input,79,FOLLOW_79_in_formalParameterList752); if (state.failed) return retval; 
            	        			    	if ( (state.backtracking==0) ) stream_79.Add(char_literal42);

            	        			    	PushFollow(FOLLOW_variableDeclaration_in_formalParameterList754);
            	        			    	variableDeclaration43 = variableDeclaration();
            	        			    	state.followingStackPointer--;
            	        			    	if (state.failed) return retval;
            	        			    	if ( (state.backtracking==0) ) stream_variableDeclaration.Add(variableDeclaration43.Tree);

            	        			    }
            	        			    break;

            	        			default:
            	        			    goto loop9;
            	        	    }
            	        	} while (true);

            	        	loop9:
            	        		;	// Stops C# compiler whining that label 'loop9' has no statements


            	        }
            	        break;

            	}



            	// AST REWRITE
            	// elements:          variableDeclaration
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 153:54: -> ^( PARAMS ( variableDeclaration )* )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:153:57: ^( PARAMS ( variableDeclaration )* )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PARAMS, "PARAMS"), root_1);

            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:153:66: ( variableDeclaration )*
            	    while ( stream_variableDeclaration.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_variableDeclaration.NextTree());

            	    }
            	    stream_variableDeclaration.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 17, formalParameterList_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "formalParameterList"

    public class variableDeclaration_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "variableDeclaration"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:156:1: variableDeclaration : typeSpecifier identifier -> ^( DECLARATION typeSpecifier identifier ) ;
    public GodPlGrammarParser.variableDeclaration_return variableDeclaration() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.variableDeclaration_return retval = new GodPlGrammarParser.variableDeclaration_return();
        retval.Start = input.LT(1);
        int variableDeclaration_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.typeSpecifier_return typeSpecifier44 = default(GodPlGrammarParser.typeSpecifier_return);

        GodPlGrammarParser.identifier_return identifier45 = default(GodPlGrammarParser.identifier_return);


        RewriteRuleSubtreeStream stream_typeSpecifier = new RewriteRuleSubtreeStream(adaptor,"rule typeSpecifier");
        RewriteRuleSubtreeStream stream_identifier = new RewriteRuleSubtreeStream(adaptor,"rule identifier");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 18) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:157:2: ( typeSpecifier identifier -> ^( DECLARATION typeSpecifier identifier ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:157:4: typeSpecifier identifier
            {
            	PushFollow(FOLLOW_typeSpecifier_in_variableDeclaration778);
            	typeSpecifier44 = typeSpecifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_typeSpecifier.Add(typeSpecifier44.Tree);
            	PushFollow(FOLLOW_identifier_in_variableDeclaration780);
            	identifier45 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_identifier.Add(identifier45.Tree);


            	// AST REWRITE
            	// elements:          identifier, typeSpecifier
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 157:29: -> ^( DECLARATION typeSpecifier identifier )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:157:32: ^( DECLARATION typeSpecifier identifier )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(DECLARATION, "DECLARATION"), root_1);

            	    adaptor.AddChild(root_1, stream_typeSpecifier.NextTree());
            	    adaptor.AddChild(root_1, stream_identifier.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 18, variableDeclaration_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "variableDeclaration"

    public class tentativeInitialization_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "tentativeInitialization"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:160:1: tentativeInitialization : ( variableDeclaration ';' -> variableDeclaration | variableDeclaration ASSIGN expression ';' -> ^( ASSIGN variableDeclaration expression ) );
    public GodPlGrammarParser.tentativeInitialization_return tentativeInitialization() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.tentativeInitialization_return retval = new GodPlGrammarParser.tentativeInitialization_return();
        retval.Start = input.LT(1);
        int tentativeInitialization_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal47 = null;
        IToken ASSIGN49 = null;
        IToken char_literal51 = null;
        GodPlGrammarParser.variableDeclaration_return variableDeclaration46 = default(GodPlGrammarParser.variableDeclaration_return);

        GodPlGrammarParser.variableDeclaration_return variableDeclaration48 = default(GodPlGrammarParser.variableDeclaration_return);

        GodPlGrammarParser.expression_return expression50 = default(GodPlGrammarParser.expression_return);


        object char_literal47_tree=null;
        object ASSIGN49_tree=null;
        object char_literal51_tree=null;
        RewriteRuleTokenStream stream_78 = new RewriteRuleTokenStream(adaptor,"token 78");
        RewriteRuleTokenStream stream_ASSIGN = new RewriteRuleTokenStream(adaptor,"token ASSIGN");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_variableDeclaration = new RewriteRuleSubtreeStream(adaptor,"rule variableDeclaration");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 19) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:161:2: ( variableDeclaration ';' -> variableDeclaration | variableDeclaration ASSIGN expression ';' -> ^( ASSIGN variableDeclaration expression ) )
            int alt11 = 2;
            int LA11_0 = input.LA(1);

            if ( ((LA11_0 >= 72 && LA11_0 <= 73)) )
            {
                int LA11_1 = input.LA(2);

                if ( (LA11_1 == UpperIdentifier || LA11_1 == LowerIdentifier) )
                {
                    int LA11_3 = input.LA(3);

                    if ( (LA11_3 == 78) )
                    {
                        alt11 = 1;
                    }
                    else if ( (LA11_3 == ASSIGN) )
                    {
                        alt11 = 2;
                    }
                    else 
                    {
                        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                        NoViableAltException nvae_d11s3 =
                            new NoViableAltException("", 11, 3, input);

                        throw nvae_d11s3;
                    }
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d11s1 =
                        new NoViableAltException("", 11, 1, input);

                    throw nvae_d11s1;
                }
            }
            else if ( (LA11_0 == UpperIdentifier) )
            {
                int LA11_2 = input.LA(2);

                if ( (LA11_2 == UpperIdentifier || LA11_2 == LowerIdentifier) )
                {
                    int LA11_3 = input.LA(3);

                    if ( (LA11_3 == 78) )
                    {
                        alt11 = 1;
                    }
                    else if ( (LA11_3 == ASSIGN) )
                    {
                        alt11 = 2;
                    }
                    else 
                    {
                        if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                        NoViableAltException nvae_d11s3 =
                            new NoViableAltException("", 11, 3, input);

                        throw nvae_d11s3;
                    }
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d11s2 =
                        new NoViableAltException("", 11, 2, input);

                    throw nvae_d11s2;
                }
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d11s0 =
                    new NoViableAltException("", 11, 0, input);

                throw nvae_d11s0;
            }
            switch (alt11) 
            {
                case 1 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:161:4: variableDeclaration ';'
                    {
                    	PushFollow(FOLLOW_variableDeclaration_in_tentativeInitialization801);
                    	variableDeclaration46 = variableDeclaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_variableDeclaration.Add(variableDeclaration46.Tree);
                    	char_literal47=(IToken)Match(input,78,FOLLOW_78_in_tentativeInitialization803); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_78.Add(char_literal47);



                    	// AST REWRITE
                    	// elements:          variableDeclaration
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (object)adaptor.GetNilNode();
                    	// 161:28: -> variableDeclaration
                    	{
                    	    adaptor.AddChild(root_0, stream_variableDeclaration.NextTree());

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 2 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:162:5: variableDeclaration ASSIGN expression ';'
                    {
                    	PushFollow(FOLLOW_variableDeclaration_in_tentativeInitialization813);
                    	variableDeclaration48 = variableDeclaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_variableDeclaration.Add(variableDeclaration48.Tree);
                    	ASSIGN49=(IToken)Match(input,ASSIGN,FOLLOW_ASSIGN_in_tentativeInitialization815); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_ASSIGN.Add(ASSIGN49);

                    	PushFollow(FOLLOW_expression_in_tentativeInitialization817);
                    	expression50 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_expression.Add(expression50.Tree);
                    	char_literal51=(IToken)Match(input,78,FOLLOW_78_in_tentativeInitialization819); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_78.Add(char_literal51);



                    	// AST REWRITE
                    	// elements:          expression, ASSIGN, variableDeclaration
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (object)adaptor.GetNilNode();
                    	// 162:47: -> ^( ASSIGN variableDeclaration expression )
                    	{
                    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:162:50: ^( ASSIGN variableDeclaration expression )
                    	    {
                    	    object root_1 = (object)adaptor.GetNilNode();
                    	    root_1 = (object)adaptor.BecomeRoot(stream_ASSIGN.NextNode(), root_1);

                    	    adaptor.AddChild(root_1, stream_variableDeclaration.NextTree());
                    	    adaptor.AddChild(root_1, stream_expression.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 19, tentativeInitialization_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "tentativeInitialization"

    public class functionName_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "functionName"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:165:1: functionName : identifier ;
    public GodPlGrammarParser.functionName_return functionName() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.functionName_return retval = new GodPlGrammarParser.functionName_return();
        retval.Start = input.LT(1);
        int functionName_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.identifier_return identifier52 = default(GodPlGrammarParser.identifier_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 20) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:166:2: ( identifier )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:166:4: identifier
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_identifier_in_functionName841);
            	identifier52 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, identifier52.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 20, functionName_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "functionName"

    public class block_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "block"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:169:1: block : '{' ( statement )* '}' -> ^( CODE ( statement )* ) ;
    public GodPlGrammarParser.block_return block() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.block_return retval = new GodPlGrammarParser.block_return();
        retval.Start = input.LT(1);
        int block_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal53 = null;
        IToken char_literal55 = null;
        GodPlGrammarParser.statement_return statement54 = default(GodPlGrammarParser.statement_return);


        object char_literal53_tree=null;
        object char_literal55_tree=null;
        RewriteRuleTokenStream stream_77 = new RewriteRuleTokenStream(adaptor,"token 77");
        RewriteRuleTokenStream stream_76 = new RewriteRuleTokenStream(adaptor,"token 76");
        RewriteRuleSubtreeStream stream_statement = new RewriteRuleSubtreeStream(adaptor,"rule statement");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 21) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:169:7: ( '{' ( statement )* '}' -> ^( CODE ( statement )* ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:169:9: '{' ( statement )* '}'
            {
            	char_literal53=(IToken)Match(input,76,FOLLOW_76_in_block852); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_76.Add(char_literal53);

            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:169:13: ( statement )*
            	do 
            	{
            	    int alt12 = 2;
            	    int LA12_0 = input.LA(1);

            	    if ( (LA12_0 == MINUS || LA12_0 == NOT || (LA12_0 >= TRUE && LA12_0 <= FALSE) || LA12_0 == EVERY || (LA12_0 >= ROLL && LA12_0 <= PICKRANDOM) || (LA12_0 >= UpperIdentifier && LA12_0 <= StringLiteral) || LA12_0 == DecimalLiteral || LA12_0 == LowerIdentifier || (LA12_0 >= 72 && LA12_0 <= 74) || LA12_0 == 80 || (LA12_0 >= 83 && LA12_0 <= 86)) )
            	    {
            	        alt12 = 1;
            	    }


            	    switch (alt12) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:0:0: statement
            			    {
            			    	PushFollow(FOLLOW_statement_in_block854);
            			    	statement54 = statement();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_statement.Add(statement54.Tree);

            			    }
            			    break;

            			default:
            			    goto loop12;
            	    }
            	} while (true);

            	loop12:
            		;	// Stops C# compiler whining that label 'loop12' has no statements

            	char_literal55=(IToken)Match(input,77,FOLLOW_77_in_block857); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_77.Add(char_literal55);



            	// AST REWRITE
            	// elements:          statement
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 169:28: -> ^( CODE ( statement )* )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:169:31: ^( CODE ( statement )* )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(CODE, "CODE"), root_1);

            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:169:38: ( statement )*
            	    while ( stream_statement.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_statement.NextTree());

            	    }
            	    stream_statement.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 21, block_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "block"

    public class statement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "statement"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:172:1: statement : ( expressionStatement | ifStatement | whileStatement | forEachStatement | breakStatement | returnStatement );
    public GodPlGrammarParser.statement_return statement() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.statement_return retval = new GodPlGrammarParser.statement_return();
        retval.Start = input.LT(1);
        int statement_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.expressionStatement_return expressionStatement56 = default(GodPlGrammarParser.expressionStatement_return);

        GodPlGrammarParser.ifStatement_return ifStatement57 = default(GodPlGrammarParser.ifStatement_return);

        GodPlGrammarParser.whileStatement_return whileStatement58 = default(GodPlGrammarParser.whileStatement_return);

        GodPlGrammarParser.forEachStatement_return forEachStatement59 = default(GodPlGrammarParser.forEachStatement_return);

        GodPlGrammarParser.breakStatement_return breakStatement60 = default(GodPlGrammarParser.breakStatement_return);

        GodPlGrammarParser.returnStatement_return returnStatement61 = default(GodPlGrammarParser.returnStatement_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 22) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:173:2: ( expressionStatement | ifStatement | whileStatement | forEachStatement | breakStatement | returnStatement )
            int alt13 = 6;
            switch ( input.LA(1) ) 
            {
            case MINUS:
            case NOT:
            case TRUE:
            case FALSE:
            case EVERY:
            case ROLL:
            case PICKRANDOM:
            case UpperIdentifier:
            case StringLiteral:
            case DecimalLiteral:
            case LowerIdentifier:
            case 72:
            case 73:
            case 74:
            	{
                alt13 = 1;
                }
                break;
            case 80:
            	{
                alt13 = 2;
                }
                break;
            case 83:
            	{
                alt13 = 3;
                }
                break;
            case 84:
            	{
                alt13 = 4;
                }
                break;
            case 85:
            	{
                alt13 = 5;
                }
                break;
            case 86:
            	{
                alt13 = 6;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d13s0 =
            	        new NoViableAltException("", 13, 0, input);

            	    throw nvae_d13s0;
            }

            switch (alt13) 
            {
                case 1 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:173:4: expressionStatement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_expressionStatement_in_statement878);
                    	expressionStatement56 = expressionStatement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, expressionStatement56.Tree);

                    }
                    break;
                case 2 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:174:4: ifStatement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_ifStatement_in_statement883);
                    	ifStatement57 = ifStatement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, ifStatement57.Tree);

                    }
                    break;
                case 3 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:175:4: whileStatement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_whileStatement_in_statement888);
                    	whileStatement58 = whileStatement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, whileStatement58.Tree);

                    }
                    break;
                case 4 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:176:4: forEachStatement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_forEachStatement_in_statement893);
                    	forEachStatement59 = forEachStatement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, forEachStatement59.Tree);

                    }
                    break;
                case 5 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:177:4: breakStatement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_breakStatement_in_statement898);
                    	breakStatement60 = breakStatement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, breakStatement60.Tree);

                    }
                    break;
                case 6 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:178:4: returnStatement
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_returnStatement_in_statement903);
                    	returnStatement61 = returnStatement();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, returnStatement61.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 22, statement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "statement"

    public class expressionStatement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "expressionStatement"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:181:1: expressionStatement : expression ';' -> expression ;
    public GodPlGrammarParser.expressionStatement_return expressionStatement() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.expressionStatement_return retval = new GodPlGrammarParser.expressionStatement_return();
        retval.Start = input.LT(1);
        int expressionStatement_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal63 = null;
        GodPlGrammarParser.expression_return expression62 = default(GodPlGrammarParser.expression_return);


        object char_literal63_tree=null;
        RewriteRuleTokenStream stream_78 = new RewriteRuleTokenStream(adaptor,"token 78");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 23) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:182:2: ( expression ';' -> expression )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:182:4: expression ';'
            {
            	PushFollow(FOLLOW_expression_in_expressionStatement914);
            	expression62 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_expression.Add(expression62.Tree);
            	char_literal63=(IToken)Match(input,78,FOLLOW_78_in_expressionStatement916); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_78.Add(char_literal63);



            	// AST REWRITE
            	// elements:          expression
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 182:19: -> expression
            	{
            	    adaptor.AddChild(root_0, stream_expression.NextTree());

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 23, expressionStatement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "expressionStatement"

    public class ifStatement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "ifStatement"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:187:1: ifStatement : ifPiece ( elseifPiece )* ( elsePiece )? -> ^( CONDITIONAL ifPiece ( elseifPiece )* ( elsePiece )? ) ;
    public GodPlGrammarParser.ifStatement_return ifStatement() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.ifStatement_return retval = new GodPlGrammarParser.ifStatement_return();
        retval.Start = input.LT(1);
        int ifStatement_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.ifPiece_return ifPiece64 = default(GodPlGrammarParser.ifPiece_return);

        GodPlGrammarParser.elseifPiece_return elseifPiece65 = default(GodPlGrammarParser.elseifPiece_return);

        GodPlGrammarParser.elsePiece_return elsePiece66 = default(GodPlGrammarParser.elsePiece_return);


        RewriteRuleSubtreeStream stream_elseifPiece = new RewriteRuleSubtreeStream(adaptor,"rule elseifPiece");
        RewriteRuleSubtreeStream stream_ifPiece = new RewriteRuleSubtreeStream(adaptor,"rule ifPiece");
        RewriteRuleSubtreeStream stream_elsePiece = new RewriteRuleSubtreeStream(adaptor,"rule elsePiece");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 24) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:188:2: ( ifPiece ( elseifPiece )* ( elsePiece )? -> ^( CONDITIONAL ifPiece ( elseifPiece )* ( elsePiece )? ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:188:4: ifPiece ( elseifPiece )* ( elsePiece )?
            {
            	PushFollow(FOLLOW_ifPiece_in_ifStatement934);
            	ifPiece64 = ifPiece();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_ifPiece.Add(ifPiece64.Tree);
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:188:12: ( elseifPiece )*
            	do 
            	{
            	    int alt14 = 2;
            	    int LA14_0 = input.LA(1);

            	    if ( (LA14_0 == 81) )
            	    {
            	        alt14 = 1;
            	    }


            	    switch (alt14) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:0:0: elseifPiece
            			    {
            			    	PushFollow(FOLLOW_elseifPiece_in_ifStatement936);
            			    	elseifPiece65 = elseifPiece();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_elseifPiece.Add(elseifPiece65.Tree);

            			    }
            			    break;

            			default:
            			    goto loop14;
            	    }
            	} while (true);

            	loop14:
            		;	// Stops C# compiler whining that label 'loop14' has no statements

            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:188:25: ( elsePiece )?
            	int alt15 = 2;
            	int LA15_0 = input.LA(1);

            	if ( (LA15_0 == 82) )
            	{
            	    alt15 = 1;
            	}
            	switch (alt15) 
            	{
            	    case 1 :
            	        // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:0:0: elsePiece
            	        {
            	        	PushFollow(FOLLOW_elsePiece_in_ifStatement939);
            	        	elsePiece66 = elsePiece();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( (state.backtracking==0) ) stream_elsePiece.Add(elsePiece66.Tree);

            	        }
            	        break;

            	}



            	// AST REWRITE
            	// elements:          elseifPiece, elsePiece, ifPiece
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 188:36: -> ^( CONDITIONAL ifPiece ( elseifPiece )* ( elsePiece )? )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:188:39: ^( CONDITIONAL ifPiece ( elseifPiece )* ( elsePiece )? )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(CONDITIONAL, "CONDITIONAL"), root_1);

            	    adaptor.AddChild(root_1, stream_ifPiece.NextTree());
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:188:61: ( elseifPiece )*
            	    while ( stream_elseifPiece.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_elseifPiece.NextTree());

            	    }
            	    stream_elseifPiece.Reset();
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:188:74: ( elsePiece )?
            	    if ( stream_elsePiece.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_elsePiece.NextTree());

            	    }
            	    stream_elsePiece.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 24, ifStatement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "ifStatement"

    public class ifPiece_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "ifPiece"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:191:1: ifPiece : 'if' '(' expression ')' block -> ^( 'if' expression block ) ;
    public GodPlGrammarParser.ifPiece_return ifPiece() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.ifPiece_return retval = new GodPlGrammarParser.ifPiece_return();
        retval.Start = input.LT(1);
        int ifPiece_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal67 = null;
        IToken char_literal68 = null;
        IToken char_literal70 = null;
        GodPlGrammarParser.expression_return expression69 = default(GodPlGrammarParser.expression_return);

        GodPlGrammarParser.block_return block71 = default(GodPlGrammarParser.block_return);


        object string_literal67_tree=null;
        object char_literal68_tree=null;
        object char_literal70_tree=null;
        RewriteRuleTokenStream stream_80 = new RewriteRuleTokenStream(adaptor,"token 80");
        RewriteRuleTokenStream stream_74 = new RewriteRuleTokenStream(adaptor,"token 74");
        RewriteRuleTokenStream stream_75 = new RewriteRuleTokenStream(adaptor,"token 75");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_block = new RewriteRuleSubtreeStream(adaptor,"rule block");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 25) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:192:2: ( 'if' '(' expression ')' block -> ^( 'if' expression block ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:192:4: 'if' '(' expression ')' block
            {
            	string_literal67=(IToken)Match(input,80,FOLLOW_80_in_ifPiece966); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_80.Add(string_literal67);

            	char_literal68=(IToken)Match(input,74,FOLLOW_74_in_ifPiece968); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_74.Add(char_literal68);

            	PushFollow(FOLLOW_expression_in_ifPiece970);
            	expression69 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_expression.Add(expression69.Tree);
            	char_literal70=(IToken)Match(input,75,FOLLOW_75_in_ifPiece972); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_75.Add(char_literal70);

            	PushFollow(FOLLOW_block_in_ifPiece974);
            	block71 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_block.Add(block71.Tree);


            	// AST REWRITE
            	// elements:          expression, 80, block
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 192:34: -> ^( 'if' expression block )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:192:37: ^( 'if' expression block )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot(stream_80.NextNode(), root_1);

            	    adaptor.AddChild(root_1, stream_expression.NextTree());
            	    adaptor.AddChild(root_1, stream_block.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 25, ifPiece_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "ifPiece"

    public class elseifPiece_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "elseifPiece"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:195:1: elseifPiece : 'else if' '(' expression ')' block -> ^( 'else if' expression block ) ;
    public GodPlGrammarParser.elseifPiece_return elseifPiece() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.elseifPiece_return retval = new GodPlGrammarParser.elseifPiece_return();
        retval.Start = input.LT(1);
        int elseifPiece_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal72 = null;
        IToken char_literal73 = null;
        IToken char_literal75 = null;
        GodPlGrammarParser.expression_return expression74 = default(GodPlGrammarParser.expression_return);

        GodPlGrammarParser.block_return block76 = default(GodPlGrammarParser.block_return);


        object string_literal72_tree=null;
        object char_literal73_tree=null;
        object char_literal75_tree=null;
        RewriteRuleTokenStream stream_81 = new RewriteRuleTokenStream(adaptor,"token 81");
        RewriteRuleTokenStream stream_74 = new RewriteRuleTokenStream(adaptor,"token 74");
        RewriteRuleTokenStream stream_75 = new RewriteRuleTokenStream(adaptor,"token 75");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_block = new RewriteRuleSubtreeStream(adaptor,"rule block");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 26) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:196:2: ( 'else if' '(' expression ')' block -> ^( 'else if' expression block ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:196:4: 'else if' '(' expression ')' block
            {
            	string_literal72=(IToken)Match(input,81,FOLLOW_81_in_elseifPiece996); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_81.Add(string_literal72);

            	char_literal73=(IToken)Match(input,74,FOLLOW_74_in_elseifPiece998); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_74.Add(char_literal73);

            	PushFollow(FOLLOW_expression_in_elseifPiece1000);
            	expression74 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_expression.Add(expression74.Tree);
            	char_literal75=(IToken)Match(input,75,FOLLOW_75_in_elseifPiece1002); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_75.Add(char_literal75);

            	PushFollow(FOLLOW_block_in_elseifPiece1004);
            	block76 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_block.Add(block76.Tree);


            	// AST REWRITE
            	// elements:          block, 81, expression
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 196:39: -> ^( 'else if' expression block )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:196:42: ^( 'else if' expression block )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot(stream_81.NextNode(), root_1);

            	    adaptor.AddChild(root_1, stream_expression.NextTree());
            	    adaptor.AddChild(root_1, stream_block.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 26, elseifPiece_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "elseifPiece"

    public class elsePiece_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "elsePiece"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:199:1: elsePiece : 'else' block -> ^( 'else' block ) ;
    public GodPlGrammarParser.elsePiece_return elsePiece() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.elsePiece_return retval = new GodPlGrammarParser.elsePiece_return();
        retval.Start = input.LT(1);
        int elsePiece_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal77 = null;
        GodPlGrammarParser.block_return block78 = default(GodPlGrammarParser.block_return);


        object string_literal77_tree=null;
        RewriteRuleTokenStream stream_82 = new RewriteRuleTokenStream(adaptor,"token 82");
        RewriteRuleSubtreeStream stream_block = new RewriteRuleSubtreeStream(adaptor,"rule block");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 27) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:200:2: ( 'else' block -> ^( 'else' block ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:200:4: 'else' block
            {
            	string_literal77=(IToken)Match(input,82,FOLLOW_82_in_elsePiece1026); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_82.Add(string_literal77);

            	PushFollow(FOLLOW_block_in_elsePiece1028);
            	block78 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_block.Add(block78.Tree);


            	// AST REWRITE
            	// elements:          block, 82
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 200:17: -> ^( 'else' block )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:200:20: ^( 'else' block )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot(stream_82.NextNode(), root_1);

            	    adaptor.AddChild(root_1, stream_block.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 27, elsePiece_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "elsePiece"

    public class whileStatement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "whileStatement"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:203:1: whileStatement : 'while' '(' expression ')' block -> ^( 'while' expression block ) ;
    public GodPlGrammarParser.whileStatement_return whileStatement() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.whileStatement_return retval = new GodPlGrammarParser.whileStatement_return();
        retval.Start = input.LT(1);
        int whileStatement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal79 = null;
        IToken char_literal80 = null;
        IToken char_literal82 = null;
        GodPlGrammarParser.expression_return expression81 = default(GodPlGrammarParser.expression_return);

        GodPlGrammarParser.block_return block83 = default(GodPlGrammarParser.block_return);


        object string_literal79_tree=null;
        object char_literal80_tree=null;
        object char_literal82_tree=null;
        RewriteRuleTokenStream stream_83 = new RewriteRuleTokenStream(adaptor,"token 83");
        RewriteRuleTokenStream stream_74 = new RewriteRuleTokenStream(adaptor,"token 74");
        RewriteRuleTokenStream stream_75 = new RewriteRuleTokenStream(adaptor,"token 75");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_block = new RewriteRuleSubtreeStream(adaptor,"rule block");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 28) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:204:2: ( 'while' '(' expression ')' block -> ^( 'while' expression block ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:204:4: 'while' '(' expression ')' block
            {
            	string_literal79=(IToken)Match(input,83,FOLLOW_83_in_whileStatement1048); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_83.Add(string_literal79);

            	char_literal80=(IToken)Match(input,74,FOLLOW_74_in_whileStatement1050); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_74.Add(char_literal80);

            	PushFollow(FOLLOW_expression_in_whileStatement1052);
            	expression81 = expression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_expression.Add(expression81.Tree);
            	char_literal82=(IToken)Match(input,75,FOLLOW_75_in_whileStatement1054); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_75.Add(char_literal82);

            	PushFollow(FOLLOW_block_in_whileStatement1056);
            	block83 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_block.Add(block83.Tree);


            	// AST REWRITE
            	// elements:          83, block, expression
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 204:37: -> ^( 'while' expression block )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:204:40: ^( 'while' expression block )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot(stream_83.NextNode(), root_1);

            	    adaptor.AddChild(root_1, stream_expression.NextTree());
            	    adaptor.AddChild(root_1, stream_block.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 28, whileStatement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "whileStatement"

    public class forEachStatement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "forEachStatement"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:207:1: forEachStatement : 'foreach' '(' objectCategory identifier ')' block -> ^( 'foreach' objectCategory identifier block ) ;
    public GodPlGrammarParser.forEachStatement_return forEachStatement() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.forEachStatement_return retval = new GodPlGrammarParser.forEachStatement_return();
        retval.Start = input.LT(1);
        int forEachStatement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal84 = null;
        IToken char_literal85 = null;
        IToken char_literal88 = null;
        GodPlGrammarParser.objectCategory_return objectCategory86 = default(GodPlGrammarParser.objectCategory_return);

        GodPlGrammarParser.identifier_return identifier87 = default(GodPlGrammarParser.identifier_return);

        GodPlGrammarParser.block_return block89 = default(GodPlGrammarParser.block_return);


        object string_literal84_tree=null;
        object char_literal85_tree=null;
        object char_literal88_tree=null;
        RewriteRuleTokenStream stream_74 = new RewriteRuleTokenStream(adaptor,"token 74");
        RewriteRuleTokenStream stream_75 = new RewriteRuleTokenStream(adaptor,"token 75");
        RewriteRuleTokenStream stream_84 = new RewriteRuleTokenStream(adaptor,"token 84");
        RewriteRuleSubtreeStream stream_objectCategory = new RewriteRuleSubtreeStream(adaptor,"rule objectCategory");
        RewriteRuleSubtreeStream stream_block = new RewriteRuleSubtreeStream(adaptor,"rule block");
        RewriteRuleSubtreeStream stream_identifier = new RewriteRuleSubtreeStream(adaptor,"rule identifier");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 29) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:208:2: ( 'foreach' '(' objectCategory identifier ')' block -> ^( 'foreach' objectCategory identifier block ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:208:5: 'foreach' '(' objectCategory identifier ')' block
            {
            	string_literal84=(IToken)Match(input,84,FOLLOW_84_in_forEachStatement1079); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_84.Add(string_literal84);

            	char_literal85=(IToken)Match(input,74,FOLLOW_74_in_forEachStatement1081); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_74.Add(char_literal85);

            	PushFollow(FOLLOW_objectCategory_in_forEachStatement1083);
            	objectCategory86 = objectCategory();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_objectCategory.Add(objectCategory86.Tree);
            	PushFollow(FOLLOW_identifier_in_forEachStatement1085);
            	identifier87 = identifier();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_identifier.Add(identifier87.Tree);
            	char_literal88=(IToken)Match(input,75,FOLLOW_75_in_forEachStatement1087); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_75.Add(char_literal88);

            	PushFollow(FOLLOW_block_in_forEachStatement1089);
            	block89 = block();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_block.Add(block89.Tree);


            	// AST REWRITE
            	// elements:          objectCategory, block, 84, identifier
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 208:55: -> ^( 'foreach' objectCategory identifier block )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:208:58: ^( 'foreach' objectCategory identifier block )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot(stream_84.NextNode(), root_1);

            	    adaptor.AddChild(root_1, stream_objectCategory.NextTree());
            	    adaptor.AddChild(root_1, stream_identifier.NextTree());
            	    adaptor.AddChild(root_1, stream_block.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 29, forEachStatement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "forEachStatement"

    public class breakStatement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "breakStatement"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:211:1: breakStatement : 'break' ';' ;
    public GodPlGrammarParser.breakStatement_return breakStatement() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.breakStatement_return retval = new GodPlGrammarParser.breakStatement_return();
        retval.Start = input.LT(1);
        int breakStatement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal90 = null;
        IToken char_literal91 = null;

        object string_literal90_tree=null;
        object char_literal91_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 30) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:212:2: ( 'break' ';' )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:212:4: 'break' ';'
            {
            	root_0 = (object)adaptor.GetNilNode();

            	string_literal90=(IToken)Match(input,85,FOLLOW_85_in_breakStatement1113); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{string_literal90_tree = (object)adaptor.Create(string_literal90);
            		adaptor.AddChild(root_0, string_literal90_tree);
            	}
            	char_literal91=(IToken)Match(input,78,FOLLOW_78_in_breakStatement1115); if (state.failed) return retval;

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 30, breakStatement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "breakStatement"

    public class returnStatement_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "returnStatement"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:215:1: returnStatement : 'return' ( expression )? ';' -> ^( 'return' expression ) ;
    public GodPlGrammarParser.returnStatement_return returnStatement() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.returnStatement_return retval = new GodPlGrammarParser.returnStatement_return();
        retval.Start = input.LT(1);
        int returnStatement_StartIndex = input.Index();
        object root_0 = null;

        IToken string_literal92 = null;
        IToken char_literal94 = null;
        GodPlGrammarParser.expression_return expression93 = default(GodPlGrammarParser.expression_return);


        object string_literal92_tree=null;
        object char_literal94_tree=null;
        RewriteRuleTokenStream stream_78 = new RewriteRuleTokenStream(adaptor,"token 78");
        RewriteRuleTokenStream stream_86 = new RewriteRuleTokenStream(adaptor,"token 86");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 31) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:216:2: ( 'return' ( expression )? ';' -> ^( 'return' expression ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:216:4: 'return' ( expression )? ';'
            {
            	string_literal92=(IToken)Match(input,86,FOLLOW_86_in_returnStatement1127); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_86.Add(string_literal92);

            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:216:13: ( expression )?
            	int alt16 = 2;
            	int LA16_0 = input.LA(1);

            	if ( (LA16_0 == MINUS || LA16_0 == NOT || (LA16_0 >= TRUE && LA16_0 <= FALSE) || LA16_0 == EVERY || (LA16_0 >= ROLL && LA16_0 <= PICKRANDOM) || (LA16_0 >= UpperIdentifier && LA16_0 <= StringLiteral) || LA16_0 == DecimalLiteral || LA16_0 == LowerIdentifier || (LA16_0 >= 72 && LA16_0 <= 74)) )
            	{
            	    alt16 = 1;
            	}
            	switch (alt16) 
            	{
            	    case 1 :
            	        // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:0:0: expression
            	        {
            	        	PushFollow(FOLLOW_expression_in_returnStatement1129);
            	        	expression93 = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( (state.backtracking==0) ) stream_expression.Add(expression93.Tree);

            	        }
            	        break;

            	}

            	char_literal94=(IToken)Match(input,78,FOLLOW_78_in_returnStatement1132); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_78.Add(char_literal94);



            	// AST REWRITE
            	// elements:          86, expression
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 216:29: -> ^( 'return' expression )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:216:32: ^( 'return' expression )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot(stream_86.NextNode(), root_1);

            	    adaptor.AddChild(root_1, stream_expression.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 31, returnStatement_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "returnStatement"

    public class expression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "expression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:219:1: expression : assignmentExpression ;
    public GodPlGrammarParser.expression_return expression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.expression_return retval = new GodPlGrammarParser.expression_return();
        retval.Start = input.LT(1);
        int expression_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.assignmentExpression_return assignmentExpression95 = default(GodPlGrammarParser.assignmentExpression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 32) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:220:2: ( assignmentExpression )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:220:4: assignmentExpression
            {
            	root_0 = (object)adaptor.GetNilNode();

            	PushFollow(FOLLOW_assignmentExpression_in_expression1151);
            	assignmentExpression95 = assignmentExpression();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, assignmentExpression95.Tree);

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 32, expression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "expression"

    public class assignmentLeft_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "assignmentLeft"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:224:1: assignmentLeft : ( variableDeclaration | unaryExpression );
    public GodPlGrammarParser.assignmentLeft_return assignmentLeft() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.assignmentLeft_return retval = new GodPlGrammarParser.assignmentLeft_return();
        retval.Start = input.LT(1);
        int assignmentLeft_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.variableDeclaration_return variableDeclaration96 = default(GodPlGrammarParser.variableDeclaration_return);

        GodPlGrammarParser.unaryExpression_return unaryExpression97 = default(GodPlGrammarParser.unaryExpression_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 33) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:225:2: ( variableDeclaration | unaryExpression )
            int alt17 = 2;
            switch ( input.LA(1) ) 
            {
            case 72:
            case 73:
            	{
                alt17 = 1;
                }
                break;
            case UpperIdentifier:
            	{
                int LA17_2 = input.LA(2);

                if ( (LA17_2 == ASSIGN || LA17_2 == DOT || LA17_2 == 74 || LA17_2 == 87) )
                {
                    alt17 = 2;
                }
                else if ( (LA17_2 == UpperIdentifier || LA17_2 == LowerIdentifier) )
                {
                    alt17 = 1;
                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                    NoViableAltException nvae_d17s2 =
                        new NoViableAltException("", 17, 2, input);

                    throw nvae_d17s2;
                }
                }
                break;
            case MINUS:
            case NOT:
            case TRUE:
            case FALSE:
            case EVERY:
            case ROLL:
            case PICKRANDOM:
            case StringLiteral:
            case DecimalLiteral:
            case LowerIdentifier:
            case 74:
            	{
                alt17 = 2;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d17s0 =
            	        new NoViableAltException("", 17, 0, input);

            	    throw nvae_d17s0;
            }

            switch (alt17) 
            {
                case 1 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:225:4: variableDeclaration
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_variableDeclaration_in_assignmentLeft1165);
                    	variableDeclaration96 = variableDeclaration();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, variableDeclaration96.Tree);

                    }
                    break;
                case 2 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:226:4: unaryExpression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_unaryExpression_in_assignmentLeft1170);
                    	unaryExpression97 = unaryExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, unaryExpression97.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 33, assignmentLeft_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "assignmentLeft"

    public class assignmentExpression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "assignmentExpression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:231:1: assignmentExpression : ( ( assignmentLeft ASSIGN orExpression ) -> ^( ASSIGN assignmentLeft orExpression ) | orExpression );
    public GodPlGrammarParser.assignmentExpression_return assignmentExpression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.assignmentExpression_return retval = new GodPlGrammarParser.assignmentExpression_return();
        retval.Start = input.LT(1);
        int assignmentExpression_StartIndex = input.Index();
        object root_0 = null;

        IToken ASSIGN99 = null;
        GodPlGrammarParser.assignmentLeft_return assignmentLeft98 = default(GodPlGrammarParser.assignmentLeft_return);

        GodPlGrammarParser.orExpression_return orExpression100 = default(GodPlGrammarParser.orExpression_return);

        GodPlGrammarParser.orExpression_return orExpression101 = default(GodPlGrammarParser.orExpression_return);


        object ASSIGN99_tree=null;
        RewriteRuleTokenStream stream_ASSIGN = new RewriteRuleTokenStream(adaptor,"token ASSIGN");
        RewriteRuleSubtreeStream stream_assignmentLeft = new RewriteRuleSubtreeStream(adaptor,"rule assignmentLeft");
        RewriteRuleSubtreeStream stream_orExpression = new RewriteRuleSubtreeStream(adaptor,"rule orExpression");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 34) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:232:2: ( ( assignmentLeft ASSIGN orExpression ) -> ^( ASSIGN assignmentLeft orExpression ) | orExpression )
            int alt18 = 2;
            alt18 = dfa18.Predict(input);
            switch (alt18) 
            {
                case 1 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:232:4: ( assignmentLeft ASSIGN orExpression )
                    {
                    	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:232:4: ( assignmentLeft ASSIGN orExpression )
                    	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:232:5: assignmentLeft ASSIGN orExpression
                    	{
                    		PushFollow(FOLLOW_assignmentLeft_in_assignmentExpression1185);
                    		assignmentLeft98 = assignmentLeft();
                    		state.followingStackPointer--;
                    		if (state.failed) return retval;
                    		if ( (state.backtracking==0) ) stream_assignmentLeft.Add(assignmentLeft98.Tree);
                    		ASSIGN99=(IToken)Match(input,ASSIGN,FOLLOW_ASSIGN_in_assignmentExpression1187); if (state.failed) return retval; 
                    		if ( (state.backtracking==0) ) stream_ASSIGN.Add(ASSIGN99);

                    		PushFollow(FOLLOW_orExpression_in_assignmentExpression1189);
                    		orExpression100 = orExpression();
                    		state.followingStackPointer--;
                    		if (state.failed) return retval;
                    		if ( (state.backtracking==0) ) stream_orExpression.Add(orExpression100.Tree);

                    	}



                    	// AST REWRITE
                    	// elements:          orExpression, ASSIGN, assignmentLeft
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (object)adaptor.GetNilNode();
                    	// 232:41: -> ^( ASSIGN assignmentLeft orExpression )
                    	{
                    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:232:44: ^( ASSIGN assignmentLeft orExpression )
                    	    {
                    	    object root_1 = (object)adaptor.GetNilNode();
                    	    root_1 = (object)adaptor.BecomeRoot(stream_ASSIGN.NextNode(), root_1);

                    	    adaptor.AddChild(root_1, stream_assignmentLeft.NextTree());
                    	    adaptor.AddChild(root_1, stream_orExpression.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 2 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:233:4: orExpression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_orExpression_in_assignmentExpression1205);
                    	orExpression101 = orExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, orExpression101.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 34, assignmentExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "assignmentExpression"

    public class orExpression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "orExpression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:238:1: orExpression : ( andExpression -> andExpression ) ( OR a= andExpression -> ^( OR $orExpression $a) )* ;
    public GodPlGrammarParser.orExpression_return orExpression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.orExpression_return retval = new GodPlGrammarParser.orExpression_return();
        retval.Start = input.LT(1);
        int orExpression_StartIndex = input.Index();
        object root_0 = null;

        IToken OR103 = null;
        GodPlGrammarParser.andExpression_return a = default(GodPlGrammarParser.andExpression_return);

        GodPlGrammarParser.andExpression_return andExpression102 = default(GodPlGrammarParser.andExpression_return);


        object OR103_tree=null;
        RewriteRuleTokenStream stream_OR = new RewriteRuleTokenStream(adaptor,"token OR");
        RewriteRuleSubtreeStream stream_andExpression = new RewriteRuleSubtreeStream(adaptor,"rule andExpression");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 35) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:239:2: ( ( andExpression -> andExpression ) ( OR a= andExpression -> ^( OR $orExpression $a) )* )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:239:4: ( andExpression -> andExpression ) ( OR a= andExpression -> ^( OR $orExpression $a) )*
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:239:4: ( andExpression -> andExpression )
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:239:5: andExpression
            	{
            		PushFollow(FOLLOW_andExpression_in_orExpression1221);
            		andExpression102 = andExpression();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( (state.backtracking==0) ) stream_andExpression.Add(andExpression102.Tree);


            		// AST REWRITE
            		// elements:          andExpression
            		// token labels:      
            		// rule labels:       retval
            		// token list labels: 
            		// rule list labels:  
            		// wildcard labels: 
            		if ( (state.backtracking==0) ) {
            		retval.Tree = root_0;
            		RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            		root_0 = (object)adaptor.GetNilNode();
            		// 239:19: -> andExpression
            		{
            		    adaptor.AddChild(root_0, stream_andExpression.NextTree());

            		}

            		retval.Tree = root_0;retval.Tree = root_0;}
            	}

            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:239:37: ( OR a= andExpression -> ^( OR $orExpression $a) )*
            	do 
            	{
            	    int alt19 = 2;
            	    int LA19_0 = input.LA(1);

            	    if ( (LA19_0 == OR) )
            	    {
            	        alt19 = 1;
            	    }


            	    switch (alt19) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:239:38: OR a= andExpression
            			    {
            			    	OR103=(IToken)Match(input,OR,FOLLOW_OR_in_orExpression1229); if (state.failed) return retval; 
            			    	if ( (state.backtracking==0) ) stream_OR.Add(OR103);

            			    	PushFollow(FOLLOW_andExpression_in_orExpression1233);
            			    	a = andExpression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_andExpression.Add(a.Tree);


            			    	// AST REWRITE
            			    	// elements:          orExpression, OR, a
            			    	// token labels:      
            			    	// rule labels:       retval, a
            			    	// token list labels: 
            			    	// rule list labels:  
            			    	// wildcard labels: 
            			    	if ( (state.backtracking==0) ) {
            			    	retval.Tree = root_0;
            			    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
            			    	RewriteRuleSubtreeStream stream_a = new RewriteRuleSubtreeStream(adaptor, "rule a", a!=null ? a.Tree : null);

            			    	root_0 = (object)adaptor.GetNilNode();
            			    	// 239:57: -> ^( OR $orExpression $a)
            			    	{
            			    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:239:60: ^( OR $orExpression $a)
            			    	    {
            			    	    object root_1 = (object)adaptor.GetNilNode();
            			    	    root_1 = (object)adaptor.BecomeRoot(stream_OR.NextNode(), root_1);

            			    	    adaptor.AddChild(root_1, stream_retval.NextTree());
            			    	    adaptor.AddChild(root_1, stream_a.NextTree());

            			    	    adaptor.AddChild(root_0, root_1);
            			    	    }

            			    	}

            			    	retval.Tree = root_0;retval.Tree = root_0;}
            			    }
            			    break;

            			default:
            			    goto loop19;
            	    }
            	} while (true);

            	loop19:
            		;	// Stops C# compiler whining that label 'loop19' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 35, orExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "orExpression"

    public class andExpression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "andExpression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:242:1: andExpression : ( equalityExpression -> equalityExpression ) ( AND a= equalityExpression -> ^( AND $andExpression $a) )* ;
    public GodPlGrammarParser.andExpression_return andExpression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.andExpression_return retval = new GodPlGrammarParser.andExpression_return();
        retval.Start = input.LT(1);
        int andExpression_StartIndex = input.Index();
        object root_0 = null;

        IToken AND105 = null;
        GodPlGrammarParser.equalityExpression_return a = default(GodPlGrammarParser.equalityExpression_return);

        GodPlGrammarParser.equalityExpression_return equalityExpression104 = default(GodPlGrammarParser.equalityExpression_return);


        object AND105_tree=null;
        RewriteRuleTokenStream stream_AND = new RewriteRuleTokenStream(adaptor,"token AND");
        RewriteRuleSubtreeStream stream_equalityExpression = new RewriteRuleSubtreeStream(adaptor,"rule equalityExpression");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 36) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:243:2: ( ( equalityExpression -> equalityExpression ) ( AND a= equalityExpression -> ^( AND $andExpression $a) )* )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:243:4: ( equalityExpression -> equalityExpression ) ( AND a= equalityExpression -> ^( AND $andExpression $a) )*
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:243:4: ( equalityExpression -> equalityExpression )
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:243:5: equalityExpression
            	{
            		PushFollow(FOLLOW_equalityExpression_in_andExpression1261);
            		equalityExpression104 = equalityExpression();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( (state.backtracking==0) ) stream_equalityExpression.Add(equalityExpression104.Tree);


            		// AST REWRITE
            		// elements:          equalityExpression
            		// token labels:      
            		// rule labels:       retval
            		// token list labels: 
            		// rule list labels:  
            		// wildcard labels: 
            		if ( (state.backtracking==0) ) {
            		retval.Tree = root_0;
            		RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            		root_0 = (object)adaptor.GetNilNode();
            		// 243:24: -> equalityExpression
            		{
            		    adaptor.AddChild(root_0, stream_equalityExpression.NextTree());

            		}

            		retval.Tree = root_0;retval.Tree = root_0;}
            	}

            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:243:47: ( AND a= equalityExpression -> ^( AND $andExpression $a) )*
            	do 
            	{
            	    int alt20 = 2;
            	    int LA20_0 = input.LA(1);

            	    if ( (LA20_0 == AND) )
            	    {
            	        alt20 = 1;
            	    }


            	    switch (alt20) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:243:48: AND a= equalityExpression
            			    {
            			    	AND105=(IToken)Match(input,AND,FOLLOW_AND_in_andExpression1269); if (state.failed) return retval; 
            			    	if ( (state.backtracking==0) ) stream_AND.Add(AND105);

            			    	PushFollow(FOLLOW_equalityExpression_in_andExpression1273);
            			    	a = equalityExpression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_equalityExpression.Add(a.Tree);


            			    	// AST REWRITE
            			    	// elements:          a, AND, andExpression
            			    	// token labels:      
            			    	// rule labels:       retval, a
            			    	// token list labels: 
            			    	// rule list labels:  
            			    	// wildcard labels: 
            			    	if ( (state.backtracking==0) ) {
            			    	retval.Tree = root_0;
            			    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
            			    	RewriteRuleSubtreeStream stream_a = new RewriteRuleSubtreeStream(adaptor, "rule a", a!=null ? a.Tree : null);

            			    	root_0 = (object)adaptor.GetNilNode();
            			    	// 243:73: -> ^( AND $andExpression $a)
            			    	{
            			    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:243:76: ^( AND $andExpression $a)
            			    	    {
            			    	    object root_1 = (object)adaptor.GetNilNode();
            			    	    root_1 = (object)adaptor.BecomeRoot(stream_AND.NextNode(), root_1);

            			    	    adaptor.AddChild(root_1, stream_retval.NextTree());
            			    	    adaptor.AddChild(root_1, stream_a.NextTree());

            			    	    adaptor.AddChild(root_0, root_1);
            			    	    }

            			    	}

            			    	retval.Tree = root_0;retval.Tree = root_0;}
            			    }
            			    break;

            			default:
            			    goto loop20;
            	    }
            	} while (true);

            	loop20:
            		;	// Stops C# compiler whining that label 'loop20' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 36, andExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "andExpression"

    public class equalityExpression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "equalityExpression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:246:1: equalityExpression : ( relationalExpression -> relationalExpression ) ( equalityOperator a= relationalExpression -> ^( equalityOperator $equalityExpression $a) )* ;
    public GodPlGrammarParser.equalityExpression_return equalityExpression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.equalityExpression_return retval = new GodPlGrammarParser.equalityExpression_return();
        retval.Start = input.LT(1);
        int equalityExpression_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.relationalExpression_return a = default(GodPlGrammarParser.relationalExpression_return);

        GodPlGrammarParser.relationalExpression_return relationalExpression106 = default(GodPlGrammarParser.relationalExpression_return);

        GodPlGrammarParser.equalityOperator_return equalityOperator107 = default(GodPlGrammarParser.equalityOperator_return);


        RewriteRuleSubtreeStream stream_relationalExpression = new RewriteRuleSubtreeStream(adaptor,"rule relationalExpression");
        RewriteRuleSubtreeStream stream_equalityOperator = new RewriteRuleSubtreeStream(adaptor,"rule equalityOperator");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 37) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:247:2: ( ( relationalExpression -> relationalExpression ) ( equalityOperator a= relationalExpression -> ^( equalityOperator $equalityExpression $a) )* )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:247:4: ( relationalExpression -> relationalExpression ) ( equalityOperator a= relationalExpression -> ^( equalityOperator $equalityExpression $a) )*
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:247:4: ( relationalExpression -> relationalExpression )
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:247:5: relationalExpression
            	{
            		PushFollow(FOLLOW_relationalExpression_in_equalityExpression1302);
            		relationalExpression106 = relationalExpression();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( (state.backtracking==0) ) stream_relationalExpression.Add(relationalExpression106.Tree);


            		// AST REWRITE
            		// elements:          relationalExpression
            		// token labels:      
            		// rule labels:       retval
            		// token list labels: 
            		// rule list labels:  
            		// wildcard labels: 
            		if ( (state.backtracking==0) ) {
            		retval.Tree = root_0;
            		RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            		root_0 = (object)adaptor.GetNilNode();
            		// 247:26: -> relationalExpression
            		{
            		    adaptor.AddChild(root_0, stream_relationalExpression.NextTree());

            		}

            		retval.Tree = root_0;retval.Tree = root_0;}
            	}

            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:248:3: ( equalityOperator a= relationalExpression -> ^( equalityOperator $equalityExpression $a) )*
            	do 
            	{
            	    int alt21 = 2;
            	    int LA21_0 = input.LA(1);

            	    if ( ((LA21_0 >= EQUAL && LA21_0 <= UNEQUAL)) )
            	    {
            	        alt21 = 1;
            	    }


            	    switch (alt21) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:248:4: equalityOperator a= relationalExpression
            			    {
            			    	PushFollow(FOLLOW_equalityOperator_in_equalityExpression1312);
            			    	equalityOperator107 = equalityOperator();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_equalityOperator.Add(equalityOperator107.Tree);
            			    	PushFollow(FOLLOW_relationalExpression_in_equalityExpression1316);
            			    	a = relationalExpression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_relationalExpression.Add(a.Tree);


            			    	// AST REWRITE
            			    	// elements:          a, equalityOperator, equalityExpression
            			    	// token labels:      
            			    	// rule labels:       retval, a
            			    	// token list labels: 
            			    	// rule list labels:  
            			    	// wildcard labels: 
            			    	if ( (state.backtracking==0) ) {
            			    	retval.Tree = root_0;
            			    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
            			    	RewriteRuleSubtreeStream stream_a = new RewriteRuleSubtreeStream(adaptor, "rule a", a!=null ? a.Tree : null);

            			    	root_0 = (object)adaptor.GetNilNode();
            			    	// 248:44: -> ^( equalityOperator $equalityExpression $a)
            			    	{
            			    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:248:47: ^( equalityOperator $equalityExpression $a)
            			    	    {
            			    	    object root_1 = (object)adaptor.GetNilNode();
            			    	    root_1 = (object)adaptor.BecomeRoot(stream_equalityOperator.NextNode(), root_1);

            			    	    adaptor.AddChild(root_1, stream_retval.NextTree());
            			    	    adaptor.AddChild(root_1, stream_a.NextTree());

            			    	    adaptor.AddChild(root_0, root_1);
            			    	    }

            			    	}

            			    	retval.Tree = root_0;retval.Tree = root_0;}
            			    }
            			    break;

            			default:
            			    goto loop21;
            	    }
            	} while (true);

            	loop21:
            		;	// Stops C# compiler whining that label 'loop21' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 37, equalityExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "equalityExpression"

    public class comparisonOperator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "comparisonOperator"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:253:1: comparisonOperator : ( equalityOperator | relationalOperator );
    public GodPlGrammarParser.comparisonOperator_return comparisonOperator() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.comparisonOperator_return retval = new GodPlGrammarParser.comparisonOperator_return();
        retval.Start = input.LT(1);
        int comparisonOperator_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.equalityOperator_return equalityOperator108 = default(GodPlGrammarParser.equalityOperator_return);

        GodPlGrammarParser.relationalOperator_return relationalOperator109 = default(GodPlGrammarParser.relationalOperator_return);



        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 38) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:254:2: ( equalityOperator | relationalOperator )
            int alt22 = 2;
            int LA22_0 = input.LA(1);

            if ( ((LA22_0 >= EQUAL && LA22_0 <= UNEQUAL)) )
            {
                alt22 = 1;
            }
            else if ( ((LA22_0 >= LESS && LA22_0 <= GREATER) || (LA22_0 >= LEQUAL && LA22_0 <= GEQUAL)) )
            {
                alt22 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d22s0 =
                    new NoViableAltException("", 22, 0, input);

                throw nvae_d22s0;
            }
            switch (alt22) 
            {
                case 1 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:254:4: equalityOperator
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_equalityOperator_in_comparisonOperator1347);
                    	equalityOperator108 = equalityOperator();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, equalityOperator108.Tree);

                    }
                    break;
                case 2 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:254:23: relationalOperator
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_relationalOperator_in_comparisonOperator1351);
                    	relationalOperator109 = relationalOperator();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, relationalOperator109.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 38, comparisonOperator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "comparisonOperator"

    public class equalityOperator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "equalityOperator"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:257:1: equalityOperator : ( EQUAL | UNEQUAL );
    public GodPlGrammarParser.equalityOperator_return equalityOperator() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.equalityOperator_return retval = new GodPlGrammarParser.equalityOperator_return();
        retval.Start = input.LT(1);
        int equalityOperator_StartIndex = input.Index();
        object root_0 = null;

        IToken set110 = null;

        object set110_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 39) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:258:2: ( EQUAL | UNEQUAL )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set110 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= EQUAL && input.LA(1) <= UNEQUAL) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set110));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 39, equalityOperator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "equalityOperator"

    public class relationalOperator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "relationalOperator"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:261:1: relationalOperator : ( LESS | GREATER | LEQUAL | GEQUAL );
    public GodPlGrammarParser.relationalOperator_return relationalOperator() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.relationalOperator_return retval = new GodPlGrammarParser.relationalOperator_return();
        retval.Start = input.LT(1);
        int relationalOperator_StartIndex = input.Index();
        object root_0 = null;

        IToken set111 = null;

        object set111_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 40) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:262:2: ( LESS | GREATER | LEQUAL | GEQUAL )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set111 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= LESS && input.LA(1) <= GREATER) || (input.LA(1) >= LEQUAL && input.LA(1) <= GEQUAL) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set111));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 40, relationalOperator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "relationalOperator"

    public class relationalExpression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "relationalExpression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:265:1: relationalExpression : ( additiveExpression -> additiveExpression ) ( relationalOperator a= additiveExpression -> ^( relationalOperator $relationalExpression $a) )* ;
    public GodPlGrammarParser.relationalExpression_return relationalExpression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.relationalExpression_return retval = new GodPlGrammarParser.relationalExpression_return();
        retval.Start = input.LT(1);
        int relationalExpression_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.additiveExpression_return a = default(GodPlGrammarParser.additiveExpression_return);

        GodPlGrammarParser.additiveExpression_return additiveExpression112 = default(GodPlGrammarParser.additiveExpression_return);

        GodPlGrammarParser.relationalOperator_return relationalOperator113 = default(GodPlGrammarParser.relationalOperator_return);


        RewriteRuleSubtreeStream stream_relationalOperator = new RewriteRuleSubtreeStream(adaptor,"rule relationalOperator");
        RewriteRuleSubtreeStream stream_additiveExpression = new RewriteRuleSubtreeStream(adaptor,"rule additiveExpression");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 41) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:266:2: ( ( additiveExpression -> additiveExpression ) ( relationalOperator a= additiveExpression -> ^( relationalOperator $relationalExpression $a) )* )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:266:4: ( additiveExpression -> additiveExpression ) ( relationalOperator a= additiveExpression -> ^( relationalOperator $relationalExpression $a) )*
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:266:4: ( additiveExpression -> additiveExpression )
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:266:5: additiveExpression
            	{
            		PushFollow(FOLLOW_additiveExpression_in_relationalExpression1404);
            		additiveExpression112 = additiveExpression();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( (state.backtracking==0) ) stream_additiveExpression.Add(additiveExpression112.Tree);


            		// AST REWRITE
            		// elements:          additiveExpression
            		// token labels:      
            		// rule labels:       retval
            		// token list labels: 
            		// rule list labels:  
            		// wildcard labels: 
            		if ( (state.backtracking==0) ) {
            		retval.Tree = root_0;
            		RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            		root_0 = (object)adaptor.GetNilNode();
            		// 266:24: -> additiveExpression
            		{
            		    adaptor.AddChild(root_0, stream_additiveExpression.NextTree());

            		}

            		retval.Tree = root_0;retval.Tree = root_0;}
            	}

            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:267:3: ( relationalOperator a= additiveExpression -> ^( relationalOperator $relationalExpression $a) )*
            	do 
            	{
            	    int alt23 = 2;
            	    int LA23_0 = input.LA(1);

            	    if ( ((LA23_0 >= LESS && LA23_0 <= GREATER) || (LA23_0 >= LEQUAL && LA23_0 <= GEQUAL)) )
            	    {
            	        alt23 = 1;
            	    }


            	    switch (alt23) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:267:4: relationalOperator a= additiveExpression
            			    {
            			    	PushFollow(FOLLOW_relationalOperator_in_relationalExpression1414);
            			    	relationalOperator113 = relationalOperator();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_relationalOperator.Add(relationalOperator113.Tree);
            			    	PushFollow(FOLLOW_additiveExpression_in_relationalExpression1418);
            			    	a = additiveExpression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_additiveExpression.Add(a.Tree);


            			    	// AST REWRITE
            			    	// elements:          relationalExpression, a, relationalOperator
            			    	// token labels:      
            			    	// rule labels:       retval, a
            			    	// token list labels: 
            			    	// rule list labels:  
            			    	// wildcard labels: 
            			    	if ( (state.backtracking==0) ) {
            			    	retval.Tree = root_0;
            			    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
            			    	RewriteRuleSubtreeStream stream_a = new RewriteRuleSubtreeStream(adaptor, "rule a", a!=null ? a.Tree : null);

            			    	root_0 = (object)adaptor.GetNilNode();
            			    	// 267:44: -> ^( relationalOperator $relationalExpression $a)
            			    	{
            			    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:267:47: ^( relationalOperator $relationalExpression $a)
            			    	    {
            			    	    object root_1 = (object)adaptor.GetNilNode();
            			    	    root_1 = (object)adaptor.BecomeRoot(stream_relationalOperator.NextNode(), root_1);

            			    	    adaptor.AddChild(root_1, stream_retval.NextTree());
            			    	    adaptor.AddChild(root_1, stream_a.NextTree());

            			    	    adaptor.AddChild(root_0, root_1);
            			    	    }

            			    	}

            			    	retval.Tree = root_0;retval.Tree = root_0;}
            			    }
            			    break;

            			default:
            			    goto loop23;
            	    }
            	} while (true);

            	loop23:
            		;	// Stops C# compiler whining that label 'loop23' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 41, relationalExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "relationalExpression"

    public class additiveExpression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "additiveExpression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:270:1: additiveExpression : ( multiplicativeExpression -> multiplicativeExpression ) ( additiveOperator a= multiplicativeExpression -> ^( additiveOperator $additiveExpression $a) )* ;
    public GodPlGrammarParser.additiveExpression_return additiveExpression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.additiveExpression_return retval = new GodPlGrammarParser.additiveExpression_return();
        retval.Start = input.LT(1);
        int additiveExpression_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.multiplicativeExpression_return a = default(GodPlGrammarParser.multiplicativeExpression_return);

        GodPlGrammarParser.multiplicativeExpression_return multiplicativeExpression114 = default(GodPlGrammarParser.multiplicativeExpression_return);

        GodPlGrammarParser.additiveOperator_return additiveOperator115 = default(GodPlGrammarParser.additiveOperator_return);


        RewriteRuleSubtreeStream stream_additiveOperator = new RewriteRuleSubtreeStream(adaptor,"rule additiveOperator");
        RewriteRuleSubtreeStream stream_multiplicativeExpression = new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeExpression");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 42) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:271:2: ( ( multiplicativeExpression -> multiplicativeExpression ) ( additiveOperator a= multiplicativeExpression -> ^( additiveOperator $additiveExpression $a) )* )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:271:4: ( multiplicativeExpression -> multiplicativeExpression ) ( additiveOperator a= multiplicativeExpression -> ^( additiveOperator $additiveExpression $a) )*
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:271:4: ( multiplicativeExpression -> multiplicativeExpression )
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:271:5: multiplicativeExpression
            	{
            		PushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression1446);
            		multiplicativeExpression114 = multiplicativeExpression();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( (state.backtracking==0) ) stream_multiplicativeExpression.Add(multiplicativeExpression114.Tree);


            		// AST REWRITE
            		// elements:          multiplicativeExpression
            		// token labels:      
            		// rule labels:       retval
            		// token list labels: 
            		// rule list labels:  
            		// wildcard labels: 
            		if ( (state.backtracking==0) ) {
            		retval.Tree = root_0;
            		RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            		root_0 = (object)adaptor.GetNilNode();
            		// 271:30: -> multiplicativeExpression
            		{
            		    adaptor.AddChild(root_0, stream_multiplicativeExpression.NextTree());

            		}

            		retval.Tree = root_0;retval.Tree = root_0;}
            	}

            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:272:3: ( additiveOperator a= multiplicativeExpression -> ^( additiveOperator $additiveExpression $a) )*
            	do 
            	{
            	    int alt24 = 2;
            	    int LA24_0 = input.LA(1);

            	    if ( ((LA24_0 >= PLUS && LA24_0 <= MINUS)) )
            	    {
            	        alt24 = 1;
            	    }


            	    switch (alt24) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:272:4: additiveOperator a= multiplicativeExpression
            			    {
            			    	PushFollow(FOLLOW_additiveOperator_in_additiveExpression1456);
            			    	additiveOperator115 = additiveOperator();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_additiveOperator.Add(additiveOperator115.Tree);
            			    	PushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression1460);
            			    	a = multiplicativeExpression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_multiplicativeExpression.Add(a.Tree);


            			    	// AST REWRITE
            			    	// elements:          a, additiveOperator, additiveExpression
            			    	// token labels:      
            			    	// rule labels:       retval, a
            			    	// token list labels: 
            			    	// rule list labels:  
            			    	// wildcard labels: 
            			    	if ( (state.backtracking==0) ) {
            			    	retval.Tree = root_0;
            			    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
            			    	RewriteRuleSubtreeStream stream_a = new RewriteRuleSubtreeStream(adaptor, "rule a", a!=null ? a.Tree : null);

            			    	root_0 = (object)adaptor.GetNilNode();
            			    	// 272:48: -> ^( additiveOperator $additiveExpression $a)
            			    	{
            			    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:272:51: ^( additiveOperator $additiveExpression $a)
            			    	    {
            			    	    object root_1 = (object)adaptor.GetNilNode();
            			    	    root_1 = (object)adaptor.BecomeRoot(stream_additiveOperator.NextNode(), root_1);

            			    	    adaptor.AddChild(root_1, stream_retval.NextTree());
            			    	    adaptor.AddChild(root_1, stream_a.NextTree());

            			    	    adaptor.AddChild(root_0, root_1);
            			    	    }

            			    	}

            			    	retval.Tree = root_0;retval.Tree = root_0;}
            			    }
            			    break;

            			default:
            			    goto loop24;
            	    }
            	} while (true);

            	loop24:
            		;	// Stops C# compiler whining that label 'loop24' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 42, additiveExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "additiveExpression"

    public class additiveOperator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "additiveOperator"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:275:1: additiveOperator : ( PLUS | MINUS );
    public GodPlGrammarParser.additiveOperator_return additiveOperator() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.additiveOperator_return retval = new GodPlGrammarParser.additiveOperator_return();
        retval.Start = input.LT(1);
        int additiveOperator_StartIndex = input.Index();
        object root_0 = null;

        IToken set116 = null;

        object set116_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 43) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:276:2: ( PLUS | MINUS )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set116 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= PLUS && input.LA(1) <= MINUS) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set116));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 43, additiveOperator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "additiveOperator"

    public class multiplicativeExpression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "multiplicativeExpression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:279:1: multiplicativeExpression : ( unaryExpression -> unaryExpression ) ( multiplicativeOperator a= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $a) )* ;
    public GodPlGrammarParser.multiplicativeExpression_return multiplicativeExpression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.multiplicativeExpression_return retval = new GodPlGrammarParser.multiplicativeExpression_return();
        retval.Start = input.LT(1);
        int multiplicativeExpression_StartIndex = input.Index();
        object root_0 = null;

        GodPlGrammarParser.unaryExpression_return a = default(GodPlGrammarParser.unaryExpression_return);

        GodPlGrammarParser.unaryExpression_return unaryExpression117 = default(GodPlGrammarParser.unaryExpression_return);

        GodPlGrammarParser.multiplicativeOperator_return multiplicativeOperator118 = default(GodPlGrammarParser.multiplicativeOperator_return);


        RewriteRuleSubtreeStream stream_multiplicativeOperator = new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeOperator");
        RewriteRuleSubtreeStream stream_unaryExpression = new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 44) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:280:2: ( ( unaryExpression -> unaryExpression ) ( multiplicativeOperator a= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $a) )* )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:280:4: ( unaryExpression -> unaryExpression ) ( multiplicativeOperator a= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $a) )*
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:280:4: ( unaryExpression -> unaryExpression )
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:280:5: unaryExpression
            	{
            		PushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression1504);
            		unaryExpression117 = unaryExpression();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( (state.backtracking==0) ) stream_unaryExpression.Add(unaryExpression117.Tree);


            		// AST REWRITE
            		// elements:          unaryExpression
            		// token labels:      
            		// rule labels:       retval
            		// token list labels: 
            		// rule list labels:  
            		// wildcard labels: 
            		if ( (state.backtracking==0) ) {
            		retval.Tree = root_0;
            		RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            		root_0 = (object)adaptor.GetNilNode();
            		// 280:21: -> unaryExpression
            		{
            		    adaptor.AddChild(root_0, stream_unaryExpression.NextTree());

            		}

            		retval.Tree = root_0;retval.Tree = root_0;}
            	}

            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:281:3: ( multiplicativeOperator a= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $a) )*
            	do 
            	{
            	    int alt25 = 2;
            	    int LA25_0 = input.LA(1);

            	    if ( ((LA25_0 >= TIMES && LA25_0 <= MOD)) )
            	    {
            	        alt25 = 1;
            	    }


            	    switch (alt25) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:281:4: multiplicativeOperator a= unaryExpression
            			    {
            			    	PushFollow(FOLLOW_multiplicativeOperator_in_multiplicativeExpression1514);
            			    	multiplicativeOperator118 = multiplicativeOperator();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_multiplicativeOperator.Add(multiplicativeOperator118.Tree);
            			    	PushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression1518);
            			    	a = unaryExpression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_unaryExpression.Add(a.Tree);


            			    	// AST REWRITE
            			    	// elements:          multiplicativeOperator, multiplicativeExpression, a
            			    	// token labels:      
            			    	// rule labels:       retval, a
            			    	// token list labels: 
            			    	// rule list labels:  
            			    	// wildcard labels: 
            			    	if ( (state.backtracking==0) ) {
            			    	retval.Tree = root_0;
            			    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
            			    	RewriteRuleSubtreeStream stream_a = new RewriteRuleSubtreeStream(adaptor, "rule a", a!=null ? a.Tree : null);

            			    	root_0 = (object)adaptor.GetNilNode();
            			    	// 281:45: -> ^( multiplicativeOperator $multiplicativeExpression $a)
            			    	{
            			    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:281:48: ^( multiplicativeOperator $multiplicativeExpression $a)
            			    	    {
            			    	    object root_1 = (object)adaptor.GetNilNode();
            			    	    root_1 = (object)adaptor.BecomeRoot(stream_multiplicativeOperator.NextNode(), root_1);

            			    	    adaptor.AddChild(root_1, stream_retval.NextTree());
            			    	    adaptor.AddChild(root_1, stream_a.NextTree());

            			    	    adaptor.AddChild(root_0, root_1);
            			    	    }

            			    	}

            			    	retval.Tree = root_0;retval.Tree = root_0;}
            			    }
            			    break;

            			default:
            			    goto loop25;
            	    }
            	} while (true);

            	loop25:
            		;	// Stops C# compiler whining that label 'loop25' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 44, multiplicativeExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "multiplicativeExpression"

    public class multiplicativeOperator_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "multiplicativeOperator"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:284:1: multiplicativeOperator : ( TIMES | DIVIDE | MOD );
    public GodPlGrammarParser.multiplicativeOperator_return multiplicativeOperator() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.multiplicativeOperator_return retval = new GodPlGrammarParser.multiplicativeOperator_return();
        retval.Start = input.LT(1);
        int multiplicativeOperator_StartIndex = input.Index();
        object root_0 = null;

        IToken set119 = null;

        object set119_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 45) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:285:2: ( TIMES | DIVIDE | MOD )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set119 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= TIMES && input.LA(1) <= MOD) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set119));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 45, multiplicativeOperator_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "multiplicativeOperator"

    public class unaryExpression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "unaryExpression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:289:1: unaryExpression : ( postfixExpression | NOT primaryExpression -> ^( NOT primaryExpression ) | MINUS primaryExpression -> ^( UNARYMINUS primaryExpression ) );
    public GodPlGrammarParser.unaryExpression_return unaryExpression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.unaryExpression_return retval = new GodPlGrammarParser.unaryExpression_return();
        retval.Start = input.LT(1);
        int unaryExpression_StartIndex = input.Index();
        object root_0 = null;

        IToken NOT121 = null;
        IToken MINUS123 = null;
        GodPlGrammarParser.postfixExpression_return postfixExpression120 = default(GodPlGrammarParser.postfixExpression_return);

        GodPlGrammarParser.primaryExpression_return primaryExpression122 = default(GodPlGrammarParser.primaryExpression_return);

        GodPlGrammarParser.primaryExpression_return primaryExpression124 = default(GodPlGrammarParser.primaryExpression_return);


        object NOT121_tree=null;
        object MINUS123_tree=null;
        RewriteRuleTokenStream stream_NOT = new RewriteRuleTokenStream(adaptor,"token NOT");
        RewriteRuleTokenStream stream_MINUS = new RewriteRuleTokenStream(adaptor,"token MINUS");
        RewriteRuleSubtreeStream stream_primaryExpression = new RewriteRuleSubtreeStream(adaptor,"rule primaryExpression");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 46) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:290:2: ( postfixExpression | NOT primaryExpression -> ^( NOT primaryExpression ) | MINUS primaryExpression -> ^( UNARYMINUS primaryExpression ) )
            int alt26 = 3;
            switch ( input.LA(1) ) 
            {
            case TRUE:
            case FALSE:
            case EVERY:
            case ROLL:
            case PICKRANDOM:
            case UpperIdentifier:
            case StringLiteral:
            case DecimalLiteral:
            case LowerIdentifier:
            case 74:
            	{
                alt26 = 1;
                }
                break;
            case NOT:
            	{
                alt26 = 2;
                }
                break;
            case MINUS:
            	{
                alt26 = 3;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    NoViableAltException nvae_d26s0 =
            	        new NoViableAltException("", 26, 0, input);

            	    throw nvae_d26s0;
            }

            switch (alt26) 
            {
                case 1 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:290:4: postfixExpression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_postfixExpression_in_unaryExpression1565);
                    	postfixExpression120 = postfixExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, postfixExpression120.Tree);

                    }
                    break;
                case 2 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:291:6: NOT primaryExpression
                    {
                    	NOT121=(IToken)Match(input,NOT,FOLLOW_NOT_in_unaryExpression1572); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_NOT.Add(NOT121);

                    	PushFollow(FOLLOW_primaryExpression_in_unaryExpression1574);
                    	primaryExpression122 = primaryExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_primaryExpression.Add(primaryExpression122.Tree);


                    	// AST REWRITE
                    	// elements:          primaryExpression, NOT
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (object)adaptor.GetNilNode();
                    	// 291:28: -> ^( NOT primaryExpression )
                    	{
                    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:291:31: ^( NOT primaryExpression )
                    	    {
                    	    object root_1 = (object)adaptor.GetNilNode();
                    	    root_1 = (object)adaptor.BecomeRoot(stream_NOT.NextNode(), root_1);

                    	    adaptor.AddChild(root_1, stream_primaryExpression.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 3 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:292:5: MINUS primaryExpression
                    {
                    	MINUS123=(IToken)Match(input,MINUS,FOLLOW_MINUS_in_unaryExpression1588); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_MINUS.Add(MINUS123);

                    	PushFollow(FOLLOW_primaryExpression_in_unaryExpression1590);
                    	primaryExpression124 = primaryExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_primaryExpression.Add(primaryExpression124.Tree);


                    	// AST REWRITE
                    	// elements:          primaryExpression
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (object)adaptor.GetNilNode();
                    	// 292:29: -> ^( UNARYMINUS primaryExpression )
                    	{
                    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:292:32: ^( UNARYMINUS primaryExpression )
                    	    {
                    	    object root_1 = (object)adaptor.GetNilNode();
                    	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(UNARYMINUS, "UNARYMINUS"), root_1);

                    	    adaptor.AddChild(root_1, stream_primaryExpression.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 46, unaryExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "unaryExpression"

    public class primaryExpression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "primaryExpression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:296:1: primaryExpression : ( identifier -> identifier | numericLiteral -> ^( NUMERICLIT numericLiteral ) | StringLiteral | timeExpression | '(' expression ')' -> ^( PARENTHESIZED expression ) | booleanLiteral | PICKRANDOM '(' objectCategory ')' -> ^( PICKRANDOM objectCategory ) | ROLL '(' expression ')' -> ^( ROLL expression ) );
    public GodPlGrammarParser.primaryExpression_return primaryExpression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.primaryExpression_return retval = new GodPlGrammarParser.primaryExpression_return();
        retval.Start = input.LT(1);
        int primaryExpression_StartIndex = input.Index();
        object root_0 = null;

        IToken StringLiteral127 = null;
        IToken char_literal129 = null;
        IToken char_literal131 = null;
        IToken PICKRANDOM133 = null;
        IToken char_literal134 = null;
        IToken char_literal136 = null;
        IToken ROLL137 = null;
        IToken char_literal138 = null;
        IToken char_literal140 = null;
        GodPlGrammarParser.identifier_return identifier125 = default(GodPlGrammarParser.identifier_return);

        GodPlGrammarParser.numericLiteral_return numericLiteral126 = default(GodPlGrammarParser.numericLiteral_return);

        GodPlGrammarParser.timeExpression_return timeExpression128 = default(GodPlGrammarParser.timeExpression_return);

        GodPlGrammarParser.expression_return expression130 = default(GodPlGrammarParser.expression_return);

        GodPlGrammarParser.booleanLiteral_return booleanLiteral132 = default(GodPlGrammarParser.booleanLiteral_return);

        GodPlGrammarParser.objectCategory_return objectCategory135 = default(GodPlGrammarParser.objectCategory_return);

        GodPlGrammarParser.expression_return expression139 = default(GodPlGrammarParser.expression_return);


        object StringLiteral127_tree=null;
        object char_literal129_tree=null;
        object char_literal131_tree=null;
        object PICKRANDOM133_tree=null;
        object char_literal134_tree=null;
        object char_literal136_tree=null;
        object ROLL137_tree=null;
        object char_literal138_tree=null;
        object char_literal140_tree=null;
        RewriteRuleTokenStream stream_PICKRANDOM = new RewriteRuleTokenStream(adaptor,"token PICKRANDOM");
        RewriteRuleTokenStream stream_ROLL = new RewriteRuleTokenStream(adaptor,"token ROLL");
        RewriteRuleTokenStream stream_74 = new RewriteRuleTokenStream(adaptor,"token 74");
        RewriteRuleTokenStream stream_75 = new RewriteRuleTokenStream(adaptor,"token 75");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_objectCategory = new RewriteRuleSubtreeStream(adaptor,"rule objectCategory");
        RewriteRuleSubtreeStream stream_numericLiteral = new RewriteRuleSubtreeStream(adaptor,"rule numericLiteral");
        RewriteRuleSubtreeStream stream_identifier = new RewriteRuleSubtreeStream(adaptor,"rule identifier");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 47) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:297:2: ( identifier -> identifier | numericLiteral -> ^( NUMERICLIT numericLiteral ) | StringLiteral | timeExpression | '(' expression ')' -> ^( PARENTHESIZED expression ) | booleanLiteral | PICKRANDOM '(' objectCategory ')' -> ^( PICKRANDOM objectCategory ) | ROLL '(' expression ')' -> ^( ROLL expression ) )
            int alt27 = 8;
            alt27 = dfa27.Predict(input);
            switch (alt27) 
            {
                case 1 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:297:4: identifier
                    {
                    	PushFollow(FOLLOW_identifier_in_primaryExpression1610);
                    	identifier125 = identifier();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_identifier.Add(identifier125.Tree);


                    	// AST REWRITE
                    	// elements:          identifier
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (object)adaptor.GetNilNode();
                    	// 297:15: -> identifier
                    	{
                    	    adaptor.AddChild(root_0, stream_identifier.NextTree());

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 2 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:298:4: numericLiteral
                    {
                    	PushFollow(FOLLOW_numericLiteral_in_primaryExpression1619);
                    	numericLiteral126 = numericLiteral();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_numericLiteral.Add(numericLiteral126.Tree);


                    	// AST REWRITE
                    	// elements:          numericLiteral
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (object)adaptor.GetNilNode();
                    	// 298:19: -> ^( NUMERICLIT numericLiteral )
                    	{
                    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:298:22: ^( NUMERICLIT numericLiteral )
                    	    {
                    	    object root_1 = (object)adaptor.GetNilNode();
                    	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(NUMERICLIT, "NUMERICLIT"), root_1);

                    	    adaptor.AddChild(root_1, stream_numericLiteral.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 3 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:299:4: StringLiteral
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	StringLiteral127=(IToken)Match(input,StringLiteral,FOLLOW_StringLiteral_in_primaryExpression1632); if (state.failed) return retval;
                    	if ( state.backtracking == 0 )
                    	{StringLiteral127_tree = (object)adaptor.Create(StringLiteral127);
                    		adaptor.AddChild(root_0, StringLiteral127_tree);
                    	}

                    }
                    break;
                case 4 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:300:4: timeExpression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_timeExpression_in_primaryExpression1637);
                    	timeExpression128 = timeExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, timeExpression128.Tree);

                    }
                    break;
                case 5 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:301:4: '(' expression ')'
                    {
                    	char_literal129=(IToken)Match(input,74,FOLLOW_74_in_primaryExpression1642); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_74.Add(char_literal129);

                    	PushFollow(FOLLOW_expression_in_primaryExpression1644);
                    	expression130 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_expression.Add(expression130.Tree);
                    	char_literal131=(IToken)Match(input,75,FOLLOW_75_in_primaryExpression1646); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_75.Add(char_literal131);



                    	// AST REWRITE
                    	// elements:          expression
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (object)adaptor.GetNilNode();
                    	// 301:23: -> ^( PARENTHESIZED expression )
                    	{
                    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:301:26: ^( PARENTHESIZED expression )
                    	    {
                    	    object root_1 = (object)adaptor.GetNilNode();
                    	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(PARENTHESIZED, "PARENTHESIZED"), root_1);

                    	    adaptor.AddChild(root_1, stream_expression.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 6 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:302:4: booleanLiteral
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_booleanLiteral_in_primaryExpression1659);
                    	booleanLiteral132 = booleanLiteral();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, booleanLiteral132.Tree);

                    }
                    break;
                case 7 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:303:4: PICKRANDOM '(' objectCategory ')'
                    {
                    	PICKRANDOM133=(IToken)Match(input,PICKRANDOM,FOLLOW_PICKRANDOM_in_primaryExpression1664); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_PICKRANDOM.Add(PICKRANDOM133);

                    	char_literal134=(IToken)Match(input,74,FOLLOW_74_in_primaryExpression1666); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_74.Add(char_literal134);

                    	PushFollow(FOLLOW_objectCategory_in_primaryExpression1668);
                    	objectCategory135 = objectCategory();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_objectCategory.Add(objectCategory135.Tree);
                    	char_literal136=(IToken)Match(input,75,FOLLOW_75_in_primaryExpression1670); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_75.Add(char_literal136);



                    	// AST REWRITE
                    	// elements:          PICKRANDOM, objectCategory
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (object)adaptor.GetNilNode();
                    	// 303:38: -> ^( PICKRANDOM objectCategory )
                    	{
                    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:303:41: ^( PICKRANDOM objectCategory )
                    	    {
                    	    object root_1 = (object)adaptor.GetNilNode();
                    	    root_1 = (object)adaptor.BecomeRoot(stream_PICKRANDOM.NextNode(), root_1);

                    	    adaptor.AddChild(root_1, stream_objectCategory.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;
                case 8 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:304:4: ROLL '(' expression ')'
                    {
                    	ROLL137=(IToken)Match(input,ROLL,FOLLOW_ROLL_in_primaryExpression1683); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_ROLL.Add(ROLL137);

                    	char_literal138=(IToken)Match(input,74,FOLLOW_74_in_primaryExpression1685); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_74.Add(char_literal138);

                    	PushFollow(FOLLOW_expression_in_primaryExpression1687);
                    	expression139 = expression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_expression.Add(expression139.Tree);
                    	char_literal140=(IToken)Match(input,75,FOLLOW_75_in_primaryExpression1689); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_75.Add(char_literal140);



                    	// AST REWRITE
                    	// elements:          expression, ROLL
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (object)adaptor.GetNilNode();
                    	// 304:28: -> ^( ROLL expression )
                    	{
                    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:304:31: ^( ROLL expression )
                    	    {
                    	    object root_1 = (object)adaptor.GetNilNode();
                    	    root_1 = (object)adaptor.BecomeRoot(stream_ROLL.NextNode(), root_1);

                    	    adaptor.AddChild(root_1, stream_expression.NextTree());

                    	    adaptor.AddChild(root_0, root_1);
                    	    }

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 47, primaryExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "primaryExpression"

    public class postfixExpression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "postfixExpression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:311:1: postfixExpression : ( primaryExpression -> primaryExpression ) ( '(' args= argumentList ')' -> ^( FUNCTIONACCESS $postfixExpression $args) | '[' ie= expression ']' -> ^( ARRAYACCESS $postfixExpression $ie) | '.' p= primaryExpression -> ^( '.' $postfixExpression $p) )* ;
    public GodPlGrammarParser.postfixExpression_return postfixExpression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.postfixExpression_return retval = new GodPlGrammarParser.postfixExpression_return();
        retval.Start = input.LT(1);
        int postfixExpression_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal142 = null;
        IToken char_literal143 = null;
        IToken char_literal144 = null;
        IToken char_literal145 = null;
        IToken char_literal146 = null;
        GodPlGrammarParser.argumentList_return args = default(GodPlGrammarParser.argumentList_return);

        GodPlGrammarParser.expression_return ie = default(GodPlGrammarParser.expression_return);

        GodPlGrammarParser.primaryExpression_return p = default(GodPlGrammarParser.primaryExpression_return);

        GodPlGrammarParser.primaryExpression_return primaryExpression141 = default(GodPlGrammarParser.primaryExpression_return);


        object char_literal142_tree=null;
        object char_literal143_tree=null;
        object char_literal144_tree=null;
        object char_literal145_tree=null;
        object char_literal146_tree=null;
        RewriteRuleTokenStream stream_DOT = new RewriteRuleTokenStream(adaptor,"token DOT");
        RewriteRuleTokenStream stream_87 = new RewriteRuleTokenStream(adaptor,"token 87");
        RewriteRuleTokenStream stream_74 = new RewriteRuleTokenStream(adaptor,"token 74");
        RewriteRuleTokenStream stream_88 = new RewriteRuleTokenStream(adaptor,"token 88");
        RewriteRuleTokenStream stream_75 = new RewriteRuleTokenStream(adaptor,"token 75");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        RewriteRuleSubtreeStream stream_primaryExpression = new RewriteRuleSubtreeStream(adaptor,"rule primaryExpression");
        RewriteRuleSubtreeStream stream_argumentList = new RewriteRuleSubtreeStream(adaptor,"rule argumentList");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 48) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:312:2: ( ( primaryExpression -> primaryExpression ) ( '(' args= argumentList ')' -> ^( FUNCTIONACCESS $postfixExpression $args) | '[' ie= expression ']' -> ^( ARRAYACCESS $postfixExpression $ie) | '.' p= primaryExpression -> ^( '.' $postfixExpression $p) )* )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:312:4: ( primaryExpression -> primaryExpression ) ( '(' args= argumentList ')' -> ^( FUNCTIONACCESS $postfixExpression $args) | '[' ie= expression ']' -> ^( ARRAYACCESS $postfixExpression $ie) | '.' p= primaryExpression -> ^( '.' $postfixExpression $p) )*
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:312:4: ( primaryExpression -> primaryExpression )
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:312:5: primaryExpression
            	{
            		PushFollow(FOLLOW_primaryExpression_in_postfixExpression1714);
            		primaryExpression141 = primaryExpression();
            		state.followingStackPointer--;
            		if (state.failed) return retval;
            		if ( (state.backtracking==0) ) stream_primaryExpression.Add(primaryExpression141.Tree);


            		// AST REWRITE
            		// elements:          primaryExpression
            		// token labels:      
            		// rule labels:       retval
            		// token list labels: 
            		// rule list labels:  
            		// wildcard labels: 
            		if ( (state.backtracking==0) ) {
            		retval.Tree = root_0;
            		RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            		root_0 = (object)adaptor.GetNilNode();
            		// 312:23: -> primaryExpression
            		{
            		    adaptor.AddChild(root_0, stream_primaryExpression.NextTree());

            		}

            		retval.Tree = root_0;retval.Tree = root_0;}
            	}

            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:313:2: ( '(' args= argumentList ')' -> ^( FUNCTIONACCESS $postfixExpression $args) | '[' ie= expression ']' -> ^( ARRAYACCESS $postfixExpression $ie) | '.' p= primaryExpression -> ^( '.' $postfixExpression $p) )*
            	do 
            	{
            	    int alt28 = 4;
            	    switch ( input.LA(1) ) 
            	    {
            	    case 74:
            	    	{
            	        alt28 = 1;
            	        }
            	        break;
            	    case 87:
            	    	{
            	        alt28 = 2;
            	        }
            	        break;
            	    case DOT:
            	    	{
            	        alt28 = 3;
            	        }
            	        break;

            	    }

            	    switch (alt28) 
            		{
            			case 1 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:313:4: '(' args= argumentList ')'
            			    {
            			    	char_literal142=(IToken)Match(input,74,FOLLOW_74_in_postfixExpression1724); if (state.failed) return retval; 
            			    	if ( (state.backtracking==0) ) stream_74.Add(char_literal142);

            			    	PushFollow(FOLLOW_argumentList_in_postfixExpression1728);
            			    	args = argumentList();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_argumentList.Add(args.Tree);
            			    	char_literal143=(IToken)Match(input,75,FOLLOW_75_in_postfixExpression1730); if (state.failed) return retval; 
            			    	if ( (state.backtracking==0) ) stream_75.Add(char_literal143);



            			    	// AST REWRITE
            			    	// elements:          args, postfixExpression
            			    	// token labels:      
            			    	// rule labels:       retval, args
            			    	// token list labels: 
            			    	// rule list labels:  
            			    	// wildcard labels: 
            			    	if ( (state.backtracking==0) ) {
            			    	retval.Tree = root_0;
            			    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
            			    	RewriteRuleSubtreeStream stream_args = new RewriteRuleSubtreeStream(adaptor, "rule args", args!=null ? args.Tree : null);

            			    	root_0 = (object)adaptor.GetNilNode();
            			    	// 313:30: -> ^( FUNCTIONACCESS $postfixExpression $args)
            			    	{
            			    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:313:33: ^( FUNCTIONACCESS $postfixExpression $args)
            			    	    {
            			    	    object root_1 = (object)adaptor.GetNilNode();
            			    	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(FUNCTIONACCESS, "FUNCTIONACCESS"), root_1);

            			    	    adaptor.AddChild(root_1, stream_retval.NextTree());
            			    	    adaptor.AddChild(root_1, stream_args.NextTree());

            			    	    adaptor.AddChild(root_0, root_1);
            			    	    }

            			    	}

            			    	retval.Tree = root_0;retval.Tree = root_0;}
            			    }
            			    break;
            			case 2 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:314:4: '[' ie= expression ']'
            			    {
            			    	char_literal144=(IToken)Match(input,87,FOLLOW_87_in_postfixExpression1747); if (state.failed) return retval; 
            			    	if ( (state.backtracking==0) ) stream_87.Add(char_literal144);

            			    	PushFollow(FOLLOW_expression_in_postfixExpression1751);
            			    	ie = expression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_expression.Add(ie.Tree);
            			    	char_literal145=(IToken)Match(input,88,FOLLOW_88_in_postfixExpression1753); if (state.failed) return retval; 
            			    	if ( (state.backtracking==0) ) stream_88.Add(char_literal145);



            			    	// AST REWRITE
            			    	// elements:          postfixExpression, ie
            			    	// token labels:      
            			    	// rule labels:       retval, ie
            			    	// token list labels: 
            			    	// rule list labels:  
            			    	// wildcard labels: 
            			    	if ( (state.backtracking==0) ) {
            			    	retval.Tree = root_0;
            			    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
            			    	RewriteRuleSubtreeStream stream_ie = new RewriteRuleSubtreeStream(adaptor, "rule ie", ie!=null ? ie.Tree : null);

            			    	root_0 = (object)adaptor.GetNilNode();
            			    	// 314:26: -> ^( ARRAYACCESS $postfixExpression $ie)
            			    	{
            			    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:314:29: ^( ARRAYACCESS $postfixExpression $ie)
            			    	    {
            			    	    object root_1 = (object)adaptor.GetNilNode();
            			    	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(ARRAYACCESS, "ARRAYACCESS"), root_1);

            			    	    adaptor.AddChild(root_1, stream_retval.NextTree());
            			    	    adaptor.AddChild(root_1, stream_ie.NextTree());

            			    	    adaptor.AddChild(root_0, root_1);
            			    	    }

            			    	}

            			    	retval.Tree = root_0;retval.Tree = root_0;}
            			    }
            			    break;
            			case 3 :
            			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:315:4: '.' p= primaryExpression
            			    {
            			    	char_literal146=(IToken)Match(input,DOT,FOLLOW_DOT_in_postfixExpression1770); if (state.failed) return retval; 
            			    	if ( (state.backtracking==0) ) stream_DOT.Add(char_literal146);

            			    	PushFollow(FOLLOW_primaryExpression_in_postfixExpression1774);
            			    	p = primaryExpression();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return retval;
            			    	if ( (state.backtracking==0) ) stream_primaryExpression.Add(p.Tree);


            			    	// AST REWRITE
            			    	// elements:          DOT, postfixExpression, p
            			    	// token labels:      
            			    	// rule labels:       retval, p
            			    	// token list labels: 
            			    	// rule list labels:  
            			    	// wildcard labels: 
            			    	if ( (state.backtracking==0) ) {
            			    	retval.Tree = root_0;
            			    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);
            			    	RewriteRuleSubtreeStream stream_p = new RewriteRuleSubtreeStream(adaptor, "rule p", p!=null ? p.Tree : null);

            			    	root_0 = (object)adaptor.GetNilNode();
            			    	// 315:28: -> ^( '.' $postfixExpression $p)
            			    	{
            			    	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:315:31: ^( '.' $postfixExpression $p)
            			    	    {
            			    	    object root_1 = (object)adaptor.GetNilNode();
            			    	    root_1 = (object)adaptor.BecomeRoot(stream_DOT.NextNode(), root_1);

            			    	    adaptor.AddChild(root_1, stream_retval.NextTree());
            			    	    adaptor.AddChild(root_1, stream_p.NextTree());

            			    	    adaptor.AddChild(root_0, root_1);
            			    	    }

            			    	}

            			    	retval.Tree = root_0;retval.Tree = root_0;}
            			    }
            			    break;

            			default:
            			    goto loop28;
            	    }
            	} while (true);

            	loop28:
            		;	// Stops C# compiler whining that label 'loop28' has no statements


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 48, postfixExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "postfixExpression"

    public class argumentList_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "argumentList"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:319:1: argumentList : ( expression ( ',' expression )* )? -> ^( ARGS ( expression )* ) ;
    public GodPlGrammarParser.argumentList_return argumentList() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.argumentList_return retval = new GodPlGrammarParser.argumentList_return();
        retval.Start = input.LT(1);
        int argumentList_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal148 = null;
        GodPlGrammarParser.expression_return expression147 = default(GodPlGrammarParser.expression_return);

        GodPlGrammarParser.expression_return expression149 = default(GodPlGrammarParser.expression_return);


        object char_literal148_tree=null;
        RewriteRuleTokenStream stream_79 = new RewriteRuleTokenStream(adaptor,"token 79");
        RewriteRuleSubtreeStream stream_expression = new RewriteRuleSubtreeStream(adaptor,"rule expression");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 49) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:320:2: ( ( expression ( ',' expression )* )? -> ^( ARGS ( expression )* ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:320:4: ( expression ( ',' expression )* )?
            {
            	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:320:4: ( expression ( ',' expression )* )?
            	int alt30 = 2;
            	int LA30_0 = input.LA(1);

            	if ( (LA30_0 == MINUS || LA30_0 == NOT || (LA30_0 >= TRUE && LA30_0 <= FALSE) || LA30_0 == EVERY || (LA30_0 >= ROLL && LA30_0 <= PICKRANDOM) || (LA30_0 >= UpperIdentifier && LA30_0 <= StringLiteral) || LA30_0 == DecimalLiteral || LA30_0 == LowerIdentifier || (LA30_0 >= 72 && LA30_0 <= 74)) )
            	{
            	    alt30 = 1;
            	}
            	switch (alt30) 
            	{
            	    case 1 :
            	        // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:320:5: expression ( ',' expression )*
            	        {
            	        	PushFollow(FOLLOW_expression_in_argumentList1803);
            	        	expression147 = expression();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return retval;
            	        	if ( (state.backtracking==0) ) stream_expression.Add(expression147.Tree);
            	        	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:320:16: ( ',' expression )*
            	        	do 
            	        	{
            	        	    int alt29 = 2;
            	        	    int LA29_0 = input.LA(1);

            	        	    if ( (LA29_0 == 79) )
            	        	    {
            	        	        alt29 = 1;
            	        	    }


            	        	    switch (alt29) 
            	        		{
            	        			case 1 :
            	        			    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:320:17: ',' expression
            	        			    {
            	        			    	char_literal148=(IToken)Match(input,79,FOLLOW_79_in_argumentList1806); if (state.failed) return retval; 
            	        			    	if ( (state.backtracking==0) ) stream_79.Add(char_literal148);

            	        			    	PushFollow(FOLLOW_expression_in_argumentList1808);
            	        			    	expression149 = expression();
            	        			    	state.followingStackPointer--;
            	        			    	if (state.failed) return retval;
            	        			    	if ( (state.backtracking==0) ) stream_expression.Add(expression149.Tree);

            	        			    }
            	        			    break;

            	        			default:
            	        			    goto loop29;
            	        	    }
            	        	} while (true);

            	        	loop29:
            	        		;	// Stops C# compiler whining that label 'loop29' has no statements


            	        }
            	        break;

            	}



            	// AST REWRITE
            	// elements:          expression
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 320:36: -> ^( ARGS ( expression )* )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:320:39: ^( ARGS ( expression )* )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(ARGS, "ARGS"), root_1);

            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:320:46: ( expression )*
            	    while ( stream_expression.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_expression.NextTree());

            	    }
            	    stream_expression.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 49, argumentList_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "argumentList"

    public class timeExpression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "timeExpression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:323:1: timeExpression : ( timeEveryExpression | '(' timeCompExpression ')' -> timeCompExpression );
    public GodPlGrammarParser.timeExpression_return timeExpression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.timeExpression_return retval = new GodPlGrammarParser.timeExpression_return();
        retval.Start = input.LT(1);
        int timeExpression_StartIndex = input.Index();
        object root_0 = null;

        IToken char_literal151 = null;
        IToken char_literal153 = null;
        GodPlGrammarParser.timeEveryExpression_return timeEveryExpression150 = default(GodPlGrammarParser.timeEveryExpression_return);

        GodPlGrammarParser.timeCompExpression_return timeCompExpression152 = default(GodPlGrammarParser.timeCompExpression_return);


        object char_literal151_tree=null;
        object char_literal153_tree=null;
        RewriteRuleTokenStream stream_74 = new RewriteRuleTokenStream(adaptor,"token 74");
        RewriteRuleTokenStream stream_75 = new RewriteRuleTokenStream(adaptor,"token 75");
        RewriteRuleSubtreeStream stream_timeCompExpression = new RewriteRuleSubtreeStream(adaptor,"rule timeCompExpression");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 50) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:324:2: ( timeEveryExpression | '(' timeCompExpression ')' -> timeCompExpression )
            int alt31 = 2;
            int LA31_0 = input.LA(1);

            if ( (LA31_0 == EVERY) )
            {
                alt31 = 1;
            }
            else if ( (LA31_0 == 74) )
            {
                alt31 = 2;
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return retval;}
                NoViableAltException nvae_d31s0 =
                    new NoViableAltException("", 31, 0, input);

                throw nvae_d31s0;
            }
            switch (alt31) 
            {
                case 1 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:324:4: timeEveryExpression
                    {
                    	root_0 = (object)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_timeEveryExpression_in_timeExpression1833);
                    	timeEveryExpression150 = timeEveryExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( state.backtracking == 0 ) adaptor.AddChild(root_0, timeEveryExpression150.Tree);

                    }
                    break;
                case 2 :
                    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:325:4: '(' timeCompExpression ')'
                    {
                    	char_literal151=(IToken)Match(input,74,FOLLOW_74_in_timeExpression1838); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_74.Add(char_literal151);

                    	PushFollow(FOLLOW_timeCompExpression_in_timeExpression1840);
                    	timeCompExpression152 = timeCompExpression();
                    	state.followingStackPointer--;
                    	if (state.failed) return retval;
                    	if ( (state.backtracking==0) ) stream_timeCompExpression.Add(timeCompExpression152.Tree);
                    	char_literal153=(IToken)Match(input,75,FOLLOW_75_in_timeExpression1842); if (state.failed) return retval; 
                    	if ( (state.backtracking==0) ) stream_75.Add(char_literal153);



                    	// AST REWRITE
                    	// elements:          timeCompExpression
                    	// token labels:      
                    	// rule labels:       retval
                    	// token list labels: 
                    	// rule list labels:  
                    	// wildcard labels: 
                    	if ( (state.backtracking==0) ) {
                    	retval.Tree = root_0;
                    	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

                    	root_0 = (object)adaptor.GetNilNode();
                    	// 325:31: -> timeCompExpression
                    	{
                    	    adaptor.AddChild(root_0, stream_timeCompExpression.NextTree());

                    	}

                    	retval.Tree = root_0;retval.Tree = root_0;}
                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 50, timeExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "timeExpression"

    public class timeEveryExpression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "timeEveryExpression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:328:1: timeEveryExpression : EVERY '(' TimeLiteral ')' -> ^( EVERY ^( TIMELIT TimeLiteral ) ) ;
    public GodPlGrammarParser.timeEveryExpression_return timeEveryExpression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.timeEveryExpression_return retval = new GodPlGrammarParser.timeEveryExpression_return();
        retval.Start = input.LT(1);
        int timeEveryExpression_StartIndex = input.Index();
        object root_0 = null;

        IToken EVERY154 = null;
        IToken char_literal155 = null;
        IToken TimeLiteral156 = null;
        IToken char_literal157 = null;

        object EVERY154_tree=null;
        object char_literal155_tree=null;
        object TimeLiteral156_tree=null;
        object char_literal157_tree=null;
        RewriteRuleTokenStream stream_EVERY = new RewriteRuleTokenStream(adaptor,"token EVERY");
        RewriteRuleTokenStream stream_TimeLiteral = new RewriteRuleTokenStream(adaptor,"token TimeLiteral");
        RewriteRuleTokenStream stream_74 = new RewriteRuleTokenStream(adaptor,"token 74");
        RewriteRuleTokenStream stream_75 = new RewriteRuleTokenStream(adaptor,"token 75");

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 51) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:329:2: ( EVERY '(' TimeLiteral ')' -> ^( EVERY ^( TIMELIT TimeLiteral ) ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:329:4: EVERY '(' TimeLiteral ')'
            {
            	EVERY154=(IToken)Match(input,EVERY,FOLLOW_EVERY_in_timeEveryExpression1858); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_EVERY.Add(EVERY154);

            	char_literal155=(IToken)Match(input,74,FOLLOW_74_in_timeEveryExpression1860); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_74.Add(char_literal155);

            	TimeLiteral156=(IToken)Match(input,TimeLiteral,FOLLOW_TimeLiteral_in_timeEveryExpression1862); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_TimeLiteral.Add(TimeLiteral156);

            	char_literal157=(IToken)Match(input,75,FOLLOW_75_in_timeEveryExpression1864); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_75.Add(char_literal157);



            	// AST REWRITE
            	// elements:          TimeLiteral, EVERY
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 329:30: -> ^( EVERY ^( TIMELIT TimeLiteral ) )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:329:33: ^( EVERY ^( TIMELIT TimeLiteral ) )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot(stream_EVERY.NextNode(), root_1);

            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:329:41: ^( TIMELIT TimeLiteral )
            	    {
            	    object root_2 = (object)adaptor.GetNilNode();
            	    root_2 = (object)adaptor.BecomeRoot((object)adaptor.Create(TIMELIT, "TIMELIT"), root_2);

            	    adaptor.AddChild(root_2, stream_TimeLiteral.NextNode());

            	    adaptor.AddChild(root_1, root_2);
            	    }

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 51, timeEveryExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "timeEveryExpression"

    public class timeCompExpression_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "timeCompExpression"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:332:1: timeCompExpression : GAMETIME comparisonOperator TimeLiteral -> ^( TIMECOMP comparisonOperator ^( TIMELIT TimeLiteral ) ) ;
    public GodPlGrammarParser.timeCompExpression_return timeCompExpression() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.timeCompExpression_return retval = new GodPlGrammarParser.timeCompExpression_return();
        retval.Start = input.LT(1);
        int timeCompExpression_StartIndex = input.Index();
        object root_0 = null;

        IToken GAMETIME158 = null;
        IToken TimeLiteral160 = null;
        GodPlGrammarParser.comparisonOperator_return comparisonOperator159 = default(GodPlGrammarParser.comparisonOperator_return);


        object GAMETIME158_tree=null;
        object TimeLiteral160_tree=null;
        RewriteRuleTokenStream stream_TimeLiteral = new RewriteRuleTokenStream(adaptor,"token TimeLiteral");
        RewriteRuleTokenStream stream_GAMETIME = new RewriteRuleTokenStream(adaptor,"token GAMETIME");
        RewriteRuleSubtreeStream stream_comparisonOperator = new RewriteRuleSubtreeStream(adaptor,"rule comparisonOperator");
        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 52) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:333:2: ( GAMETIME comparisonOperator TimeLiteral -> ^( TIMECOMP comparisonOperator ^( TIMELIT TimeLiteral ) ) )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:333:4: GAMETIME comparisonOperator TimeLiteral
            {
            	GAMETIME158=(IToken)Match(input,GAMETIME,FOLLOW_GAMETIME_in_timeCompExpression1887); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_GAMETIME.Add(GAMETIME158);

            	PushFollow(FOLLOW_comparisonOperator_in_timeCompExpression1889);
            	comparisonOperator159 = comparisonOperator();
            	state.followingStackPointer--;
            	if (state.failed) return retval;
            	if ( (state.backtracking==0) ) stream_comparisonOperator.Add(comparisonOperator159.Tree);
            	TimeLiteral160=(IToken)Match(input,TimeLiteral,FOLLOW_TimeLiteral_in_timeCompExpression1891); if (state.failed) return retval; 
            	if ( (state.backtracking==0) ) stream_TimeLiteral.Add(TimeLiteral160);



            	// AST REWRITE
            	// elements:          TimeLiteral, comparisonOperator
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	if ( (state.backtracking==0) ) {
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (object)adaptor.GetNilNode();
            	// 333:44: -> ^( TIMECOMP comparisonOperator ^( TIMELIT TimeLiteral ) )
            	{
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:333:47: ^( TIMECOMP comparisonOperator ^( TIMELIT TimeLiteral ) )
            	    {
            	    object root_1 = (object)adaptor.GetNilNode();
            	    root_1 = (object)adaptor.BecomeRoot((object)adaptor.Create(TIMECOMP, "TIMECOMP"), root_1);

            	    adaptor.AddChild(root_1, stream_comparisonOperator.NextTree());
            	    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:333:77: ^( TIMELIT TimeLiteral )
            	    {
            	    object root_2 = (object)adaptor.GetNilNode();
            	    root_2 = (object)adaptor.BecomeRoot((object)adaptor.Create(TIMELIT, "TIMELIT"), root_2);

            	    adaptor.AddChild(root_2, stream_TimeLiteral.NextNode());

            	    adaptor.AddChild(root_1, root_2);
            	    }

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;}
            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 52, timeCompExpression_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "timeCompExpression"

    public class booleanLiteral_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "booleanLiteral"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:341:1: booleanLiteral : ( TRUE | FALSE );
    public GodPlGrammarParser.booleanLiteral_return booleanLiteral() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.booleanLiteral_return retval = new GodPlGrammarParser.booleanLiteral_return();
        retval.Start = input.LT(1);
        int booleanLiteral_StartIndex = input.Index();
        object root_0 = null;

        IToken set161 = null;

        object set161_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 53) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:342:2: ( TRUE | FALSE )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set161 = (IToken)input.LT(1);
            	if ( (input.LA(1) >= TRUE && input.LA(1) <= FALSE) ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set161));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 53, booleanLiteral_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "booleanLiteral"

    public class numericLiteral_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "numericLiteral"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:344:1: numericLiteral : DecimalLiteral ;
    public GodPlGrammarParser.numericLiteral_return numericLiteral() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.numericLiteral_return retval = new GodPlGrammarParser.numericLiteral_return();
        retval.Start = input.LT(1);
        int numericLiteral_StartIndex = input.Index();
        object root_0 = null;

        IToken DecimalLiteral162 = null;

        object DecimalLiteral162_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 54) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:345:2: ( DecimalLiteral )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:345:5: DecimalLiteral
            {
            	root_0 = (object)adaptor.GetNilNode();

            	DecimalLiteral162=(IToken)Match(input,DecimalLiteral,FOLLOW_DecimalLiteral_in_numericLiteral1979); if (state.failed) return retval;
            	if ( state.backtracking == 0 )
            	{DecimalLiteral162_tree = (object)adaptor.Create(DecimalLiteral162);
            		adaptor.AddChild(root_0, DecimalLiteral162_tree);
            	}

            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 54, numericLiteral_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "numericLiteral"

    public class identifier_return : ParserRuleReturnScope
    {
        private object tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (object) value; }
        }
    };

    // $ANTLR start "identifier"
    // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:401:1: identifier : ( LowerIdentifier | UpperIdentifier );
    public GodPlGrammarParser.identifier_return identifier() // throws RecognitionException [1]
    {   
        GodPlGrammarParser.identifier_return retval = new GodPlGrammarParser.identifier_return();
        retval.Start = input.LT(1);
        int identifier_StartIndex = input.Index();
        object root_0 = null;

        IToken set163 = null;

        object set163_tree=null;

        try 
    	{
    	    if ( (state.backtracking > 0) && AlreadyParsedRule(input, 55) ) 
    	    {
    	    	return retval; 
    	    }
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:402:2: ( LowerIdentifier | UpperIdentifier )
            // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:
            {
            	root_0 = (object)adaptor.GetNilNode();

            	set163 = (IToken)input.LT(1);
            	if ( input.LA(1) == UpperIdentifier || input.LA(1) == LowerIdentifier ) 
            	{
            	    input.Consume();
            	    if ( state.backtracking == 0 ) adaptor.AddChild(root_0, (object)adaptor.Create(set163));
            	    state.errorRecovery = false;state.failed = false;
            	}
            	else 
            	{
            	    if ( state.backtracking > 0 ) {state.failed = true; return retval;}
            	    MismatchedSetException mse = new MismatchedSetException(null,input);
            	    throw mse;
            	}


            }

            retval.Stop = input.LT(-1);

            if ( (state.backtracking==0) )
            {	retval.Tree = (object)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);}
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (object)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
            if ( state.backtracking > 0 ) 
            {
            	Memoize(input, 55, identifier_StartIndex); 
            }
        }
        return retval;
    }
    // $ANTLR end "identifier"

    // $ANTLR start "synpred23_GodPlGrammar"
    public void synpred23_GodPlGrammar_fragment() {
        // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:232:4: ( ( assignmentLeft ASSIGN orExpression ) )
        // C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:232:4: ( assignmentLeft ASSIGN orExpression )
        {
        	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:232:4: ( assignmentLeft ASSIGN orExpression )
        	// C:\\Users\\Kosta\\Documents\\Visual Studio 2008\\Projects\\GodPl\\GodPl\\Parser\\GodPlGrammar.g:232:5: assignmentLeft ASSIGN orExpression
        	{
        		PushFollow(FOLLOW_assignmentLeft_in_synpred23_GodPlGrammar1185);
        		assignmentLeft();
        		state.followingStackPointer--;
        		if (state.failed) return ;
        		Match(input,ASSIGN,FOLLOW_ASSIGN_in_synpred23_GodPlGrammar1187); if (state.failed) return ;
        		PushFollow(FOLLOW_orExpression_in_synpred23_GodPlGrammar1189);
        		orExpression();
        		state.followingStackPointer--;
        		if (state.failed) return ;

        	}


        }
    }
    // $ANTLR end "synpred23_GodPlGrammar"

    // Delegated rules

   	public bool synpred23_GodPlGrammar() 
   	{
   	    state.backtracking++;
   	    int start = input.Mark();
   	    try 
   	    {
   	        synpred23_GodPlGrammar_fragment(); // can never throw exception
   	    }
   	    catch (RecognitionException re) 
   	    {
   	        Console.Error.WriteLine("impossible: "+re);
   	    }
   	    bool success = !state.failed;
   	    input.Rewind(start);
   	    state.backtracking--;
   	    state.failed = false;
   	    return success;
   	}


   	protected DFA18 dfa18;
   	protected DFA27 dfa27;
	private void InitializeCyclicDFAs()
	{
    	this.dfa18 = new DFA18(this);
    	this.dfa27 = new DFA27(this);
	    this.dfa18.specialStateTransitionHandler = new DFA.SpecialStateTransitionHandler(DFA18_SpecialStateTransition);

	}

    const string DFA18_eotS =
        "\x0e\uffff";
    const string DFA18_eofS =
        "\x0e\uffff";
    const string DFA18_minS =
        "\x01\x1e\x01\uffff\x0b\x00\x01\uffff";
    const string DFA18_maxS =
        "\x01\x4a\x01\uffff\x0b\x00\x01\uffff";
    const string DFA18_acceptS =
        "\x01\uffff\x01\x01\x0b\uffff\x01\x02";
    const string DFA18_specialS =
        "\x02\uffff\x01\x00\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01"+
        "\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\uffff}>";
    static readonly string[] DFA18_transitionS = {
            "\x01\x0c\x0b\uffff\x01\x0b\x01\uffff\x02\x08\x01\uffff\x01"+
            "\x06\x01\uffff\x01\x0a\x01\x09\x02\uffff\x01\x02\x01\x05\x01"+
            "\uffff\x01\x04\x0a\uffff\x01\x03\x04\uffff\x02\x01\x01\x07",
            "",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            "\x01\uffff",
            ""
    };

    static readonly short[] DFA18_eot = DFA.UnpackEncodedString(DFA18_eotS);
    static readonly short[] DFA18_eof = DFA.UnpackEncodedString(DFA18_eofS);
    static readonly char[] DFA18_min = DFA.UnpackEncodedStringToUnsignedChars(DFA18_minS);
    static readonly char[] DFA18_max = DFA.UnpackEncodedStringToUnsignedChars(DFA18_maxS);
    static readonly short[] DFA18_accept = DFA.UnpackEncodedString(DFA18_acceptS);
    static readonly short[] DFA18_special = DFA.UnpackEncodedString(DFA18_specialS);
    static readonly short[][] DFA18_transition = DFA.UnpackEncodedStringArray(DFA18_transitionS);

    protected class DFA18 : DFA
    {
        public DFA18(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 18;
            this.eot = DFA18_eot;
            this.eof = DFA18_eof;
            this.min = DFA18_min;
            this.max = DFA18_max;
            this.accept = DFA18_accept;
            this.special = DFA18_special;
            this.transition = DFA18_transition;

        }

        override public string Description
        {
            get { return "231:1: assignmentExpression : ( ( assignmentLeft ASSIGN orExpression ) -> ^( ASSIGN assignmentLeft orExpression ) | orExpression );"; }
        }

    }


    protected internal int DFA18_SpecialStateTransition(DFA dfa, int s, IIntStream _input) //throws NoViableAltException
    {
            ITokenStream input = (ITokenStream)_input;
    	int _s = s;
        switch ( s )
        {
               	case 0 : 
                   	int LA18_2 = input.LA(1);

                   	 
                   	int index18_2 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred23_GodPlGrammar()) ) { s = 1; }

                   	else if ( (true) ) { s = 13; }

                   	 
                   	input.Seek(index18_2);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 1 : 
                   	int LA18_3 = input.LA(1);

                   	 
                   	int index18_3 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred23_GodPlGrammar()) ) { s = 1; }

                   	else if ( (true) ) { s = 13; }

                   	 
                   	input.Seek(index18_3);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 2 : 
                   	int LA18_4 = input.LA(1);

                   	 
                   	int index18_4 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred23_GodPlGrammar()) ) { s = 1; }

                   	else if ( (true) ) { s = 13; }

                   	 
                   	input.Seek(index18_4);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 3 : 
                   	int LA18_5 = input.LA(1);

                   	 
                   	int index18_5 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred23_GodPlGrammar()) ) { s = 1; }

                   	else if ( (true) ) { s = 13; }

                   	 
                   	input.Seek(index18_5);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 4 : 
                   	int LA18_6 = input.LA(1);

                   	 
                   	int index18_6 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred23_GodPlGrammar()) ) { s = 1; }

                   	else if ( (true) ) { s = 13; }

                   	 
                   	input.Seek(index18_6);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 5 : 
                   	int LA18_7 = input.LA(1);

                   	 
                   	int index18_7 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred23_GodPlGrammar()) ) { s = 1; }

                   	else if ( (true) ) { s = 13; }

                   	 
                   	input.Seek(index18_7);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 6 : 
                   	int LA18_8 = input.LA(1);

                   	 
                   	int index18_8 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred23_GodPlGrammar()) ) { s = 1; }

                   	else if ( (true) ) { s = 13; }

                   	 
                   	input.Seek(index18_8);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 7 : 
                   	int LA18_9 = input.LA(1);

                   	 
                   	int index18_9 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred23_GodPlGrammar()) ) { s = 1; }

                   	else if ( (true) ) { s = 13; }

                   	 
                   	input.Seek(index18_9);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 8 : 
                   	int LA18_10 = input.LA(1);

                   	 
                   	int index18_10 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred23_GodPlGrammar()) ) { s = 1; }

                   	else if ( (true) ) { s = 13; }

                   	 
                   	input.Seek(index18_10);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 9 : 
                   	int LA18_11 = input.LA(1);

                   	 
                   	int index18_11 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred23_GodPlGrammar()) ) { s = 1; }

                   	else if ( (true) ) { s = 13; }

                   	 
                   	input.Seek(index18_11);
                   	if ( s >= 0 ) return s;
                   	break;
               	case 10 : 
                   	int LA18_12 = input.LA(1);

                   	 
                   	int index18_12 = input.Index();
                   	input.Rewind();
                   	s = -1;
                   	if ( (synpred23_GodPlGrammar()) ) { s = 1; }

                   	else if ( (true) ) { s = 13; }

                   	 
                   	input.Seek(index18_12);
                   	if ( s >= 0 ) return s;
                   	break;
        }
        if (state.backtracking > 0) {state.failed = true; return -1;}
        NoViableAltException nvae18 =
            new NoViableAltException(dfa.Description, 18, _s, input);
        dfa.Error(nvae18);
        throw nvae18;
    }
    const string DFA27_eotS =
        "\x0a\uffff";
    const string DFA27_eofS =
        "\x0a\uffff";
    const string DFA27_minS =
        "\x01\x2c\x04\uffff\x01\x1e\x04\uffff";
    const string DFA27_maxS =
        "\x01\x4a\x04\uffff\x01\x4a\x04\uffff";
    const string DFA27_acceptS =
        "\x01\uffff\x01\x01\x01\x02\x01\x03\x01\x04\x01\uffff\x01\x06\x01"+
        "\x07\x01\x08\x01\x05";
    const string DFA27_specialS =
        "\x0a\uffff}>";
    static readonly string[] DFA27_transitionS = {
            "\x02\x06\x01\uffff\x01\x04\x01\uffff\x01\x08\x01\x07\x02\uffff"+
            "\x01\x01\x01\x03\x01\uffff\x01\x02\x0a\uffff\x01\x01\x06\uffff"+
            "\x01\x05",
            "",
            "",
            "",
            "",
            "\x01\x09\x0b\uffff\x01\x09\x01\uffff\x02\x09\x01\x04\x01\x09"+
            "\x01\uffff\x02\x09\x02\uffff\x02\x09\x01\uffff\x01\x09\x0a\uffff"+
            "\x01\x09\x04\uffff\x03\x09",
            "",
            "",
            "",
            ""
    };

    static readonly short[] DFA27_eot = DFA.UnpackEncodedString(DFA27_eotS);
    static readonly short[] DFA27_eof = DFA.UnpackEncodedString(DFA27_eofS);
    static readonly char[] DFA27_min = DFA.UnpackEncodedStringToUnsignedChars(DFA27_minS);
    static readonly char[] DFA27_max = DFA.UnpackEncodedStringToUnsignedChars(DFA27_maxS);
    static readonly short[] DFA27_accept = DFA.UnpackEncodedString(DFA27_acceptS);
    static readonly short[] DFA27_special = DFA.UnpackEncodedString(DFA27_specialS);
    static readonly short[][] DFA27_transition = DFA.UnpackEncodedStringArray(DFA27_transitionS);

    protected class DFA27 : DFA
    {
        public DFA27(BaseRecognizer recognizer)
        {
            this.recognizer = recognizer;
            this.decisionNumber = 27;
            this.eot = DFA27_eot;
            this.eof = DFA27_eof;
            this.min = DFA27_min;
            this.max = DFA27_max;
            this.accept = DFA27_accept;
            this.special = DFA27_special;
            this.transition = DFA27_transition;

        }

        override public string Description
        {
            get { return "296:1: primaryExpression : ( identifier -> identifier | numericLiteral -> ^( NUMERICLIT numericLiteral ) | StringLiteral | timeExpression | '(' expression ')' -> ^( PARENTHESIZED expression ) | booleanLiteral | PICKRANDOM '(' objectCategory ')' -> ^( PICKRANDOM objectCategory ) | ROLL '(' expression ')' -> ^( ROLL expression ) );"; }
        }

    }

 

    public static readonly BitSet FOLLOW_68_in_program173 = new BitSet(new ulong[]{0x0020000000000000UL,0x0000000000000320UL});
    public static readonly BitSet FOLLOW_globals_in_program177 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000020UL});
    public static readonly BitSet FOLLOW_69_in_program181 = new BitSet(new ulong[]{0x0020000000000000UL,0x0000000000000340UL});
    public static readonly BitSet FOLLOW_instances_in_program185 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_70_in_program189 = new BitSet(new ulong[]{0x0030000000000000UL,0x0000000000000380UL});
    public static readonly BitSet FOLLOW_functionDefinitions_in_program193 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000080UL});
    public static readonly BitSet FOLLOW_71_in_program197 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000400UL});
    public static readonly BitSet FOLLOW_eventDefinitions_in_program201 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_primitiveType_in_typeSpecifier411 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_objectCategory_in_typeSpecifier417 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_primitiveType0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_UpperIdentifier_in_objectCategory446 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_global_in_globals457 = new BitSet(new ulong[]{0x0020000000000002UL,0x0000000000000300UL});
    public static readonly BitSet FOLLOW_tentativeInitialization_in_global480 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_instance_in_instances499 = new BitSet(new ulong[]{0x0020000000000002UL,0x0000000000000300UL});
    public static readonly BitSet FOLLOW_tentativeInitialization_in_instance522 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_tentativeInitialization_in_tentativeInitializations545 = new BitSet(new ulong[]{0x0020000000000002UL,0x0000000000000300UL});
    public static readonly BitSet FOLLOW_functionDefinition_in_functionDefinitions558 = new BitSet(new ulong[]{0x0030000000000002UL,0x0000000000000300UL});
    public static readonly BitSet FOLLOW_eventDefinition_in_eventDefinitions580 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000400UL});
    public static readonly BitSet FOLLOW_74_in_eventDefinition602 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_expression_in_eventDefinition604 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_75_in_eventDefinition606 = new BitSet(new ulong[]{0x0008000000000000UL});
    public static readonly BitSet FOLLOW_IMPLIES_in_eventDefinition608 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000001000UL});
    public static readonly BitSet FOLLOW_76_in_eventDefinition610 = new BitSet(new ulong[]{0x0020000000000000UL,0x0000000000002008UL});
    public static readonly BitSet FOLLOW_actions_in_eventDefinition612 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000002000UL});
    public static readonly BitSet FOLLOW_77_in_eventDefinition614 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_action_in_actions637 = new BitSet(new ulong[]{0x0020000000000002UL,0x0000000000000008UL});
    public static readonly BitSet FOLLOW_functionName_in_action658 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000400UL});
    public static readonly BitSet FOLLOW_74_in_action660 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000F08UL});
    public static readonly BitSet FOLLOW_argumentList_in_action662 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_75_in_action664 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000004000UL});
    public static readonly BitSet FOLLOW_78_in_action666 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_functionType_in_functionDefinition687 = new BitSet(new ulong[]{0x0020000000000000UL,0x0000000000000008UL});
    public static readonly BitSet FOLLOW_functionName_in_functionDefinition689 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000400UL});
    public static readonly BitSet FOLLOW_74_in_functionDefinition691 = new BitSet(new ulong[]{0x0020000000000000UL,0x0000000000000B00UL});
    public static readonly BitSet FOLLOW_formalParameterList_in_functionDefinition693 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_75_in_functionDefinition695 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000001000UL});
    public static readonly BitSet FOLLOW_block_in_functionDefinition697 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typeSpecifier_in_functionType730 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_VOID_in_functionType735 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variableDeclaration_in_formalParameterList749 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_79_in_formalParameterList752 = new BitSet(new ulong[]{0x0020000000000000UL,0x0000000000000300UL});
    public static readonly BitSet FOLLOW_variableDeclaration_in_formalParameterList754 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_typeSpecifier_in_variableDeclaration778 = new BitSet(new ulong[]{0x0020000000000000UL,0x0000000000000008UL});
    public static readonly BitSet FOLLOW_identifier_in_variableDeclaration780 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variableDeclaration_in_tentativeInitialization801 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000004000UL});
    public static readonly BitSet FOLLOW_78_in_tentativeInitialization803 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variableDeclaration_in_tentativeInitialization813 = new BitSet(new ulong[]{0x0000000010000000UL});
    public static readonly BitSet FOLLOW_ASSIGN_in_tentativeInitialization815 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_expression_in_tentativeInitialization817 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000004000UL});
    public static readonly BitSet FOLLOW_78_in_tentativeInitialization819 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_functionName841 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_76_in_block852 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000792708UL});
    public static readonly BitSet FOLLOW_statement_in_block854 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000792708UL});
    public static readonly BitSet FOLLOW_77_in_block857 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expressionStatement_in_statement878 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ifStatement_in_statement883 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_whileStatement_in_statement888 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_forEachStatement_in_statement893 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_breakStatement_in_statement898 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_returnStatement_in_statement903 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_expression_in_expressionStatement914 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000004000UL});
    public static readonly BitSet FOLLOW_78_in_expressionStatement916 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ifPiece_in_ifStatement934 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000060000UL});
    public static readonly BitSet FOLLOW_elseifPiece_in_ifStatement936 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000060000UL});
    public static readonly BitSet FOLLOW_elsePiece_in_ifStatement939 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_80_in_ifPiece966 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000400UL});
    public static readonly BitSet FOLLOW_74_in_ifPiece968 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_expression_in_ifPiece970 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_75_in_ifPiece972 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000001000UL});
    public static readonly BitSet FOLLOW_block_in_ifPiece974 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_81_in_elseifPiece996 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000400UL});
    public static readonly BitSet FOLLOW_74_in_elseifPiece998 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_expression_in_elseifPiece1000 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_75_in_elseifPiece1002 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000001000UL});
    public static readonly BitSet FOLLOW_block_in_elseifPiece1004 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_82_in_elsePiece1026 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000001000UL});
    public static readonly BitSet FOLLOW_block_in_elsePiece1028 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_83_in_whileStatement1048 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000400UL});
    public static readonly BitSet FOLLOW_74_in_whileStatement1050 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_expression_in_whileStatement1052 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_75_in_whileStatement1054 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000001000UL});
    public static readonly BitSet FOLLOW_block_in_whileStatement1056 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_84_in_forEachStatement1079 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000400UL});
    public static readonly BitSet FOLLOW_74_in_forEachStatement1081 = new BitSet(new ulong[]{0x0020000000000000UL,0x0000000000000300UL});
    public static readonly BitSet FOLLOW_objectCategory_in_forEachStatement1083 = new BitSet(new ulong[]{0x0020000000000000UL,0x0000000000000008UL});
    public static readonly BitSet FOLLOW_identifier_in_forEachStatement1085 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_75_in_forEachStatement1087 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000001000UL});
    public static readonly BitSet FOLLOW_block_in_forEachStatement1089 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_85_in_breakStatement1113 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000004000UL});
    public static readonly BitSet FOLLOW_78_in_breakStatement1115 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_86_in_returnStatement1127 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000004708UL});
    public static readonly BitSet FOLLOW_expression_in_returnStatement1129 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000004000UL});
    public static readonly BitSet FOLLOW_78_in_returnStatement1132 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_assignmentExpression_in_expression1151 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_variableDeclaration_in_assignmentLeft1165 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unaryExpression_in_assignmentLeft1170 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_assignmentLeft_in_assignmentExpression1185 = new BitSet(new ulong[]{0x0000000010000000UL});
    public static readonly BitSet FOLLOW_ASSIGN_in_assignmentExpression1187 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_orExpression_in_assignmentExpression1189 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_orExpression_in_assignmentExpression1205 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_andExpression_in_orExpression1221 = new BitSet(new ulong[]{0x0000010000000002UL});
    public static readonly BitSet FOLLOW_OR_in_orExpression1229 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_andExpression_in_orExpression1233 = new BitSet(new ulong[]{0x0000010000000002UL});
    public static readonly BitSet FOLLOW_equalityExpression_in_andExpression1261 = new BitSet(new ulong[]{0x0000020000000002UL});
    public static readonly BitSet FOLLOW_AND_in_andExpression1269 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_equalityExpression_in_andExpression1273 = new BitSet(new ulong[]{0x0000020000000002UL});
    public static readonly BitSet FOLLOW_relationalExpression_in_equalityExpression1302 = new BitSet(new ulong[]{0x0000003000000002UL});
    public static readonly BitSet FOLLOW_equalityOperator_in_equalityExpression1312 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_relationalExpression_in_equalityExpression1316 = new BitSet(new ulong[]{0x0000003000000002UL});
    public static readonly BitSet FOLLOW_equalityOperator_in_comparisonOperator1347 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_relationalOperator_in_comparisonOperator1351 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_equalityOperator0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_relationalOperator0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_additiveExpression_in_relationalExpression1404 = new BitSet(new ulong[]{0x000000CC00000002UL});
    public static readonly BitSet FOLLOW_relationalOperator_in_relationalExpression1414 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_additiveExpression_in_relationalExpression1418 = new BitSet(new ulong[]{0x000000CC00000002UL});
    public static readonly BitSet FOLLOW_multiplicativeExpression_in_additiveExpression1446 = new BitSet(new ulong[]{0x0000000060000002UL});
    public static readonly BitSet FOLLOW_additiveOperator_in_additiveExpression1456 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_multiplicativeExpression_in_additiveExpression1460 = new BitSet(new ulong[]{0x0000000060000002UL});
    public static readonly BitSet FOLLOW_set_in_additiveOperator0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_unaryExpression_in_multiplicativeExpression1504 = new BitSet(new ulong[]{0x0000000380000002UL});
    public static readonly BitSet FOLLOW_multiplicativeOperator_in_multiplicativeExpression1514 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_unaryExpression_in_multiplicativeExpression1518 = new BitSet(new ulong[]{0x0000000380000002UL});
    public static readonly BitSet FOLLOW_set_in_multiplicativeOperator0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_postfixExpression_in_unaryExpression1565 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NOT_in_unaryExpression1572 = new BitSet(new ulong[]{0x0166B00000000000UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_primaryExpression_in_unaryExpression1574 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_MINUS_in_unaryExpression1588 = new BitSet(new ulong[]{0x0166B00000000000UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_primaryExpression_in_unaryExpression1590 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_identifier_in_primaryExpression1610 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_numericLiteral_in_primaryExpression1619 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_StringLiteral_in_primaryExpression1632 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_timeExpression_in_primaryExpression1637 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_74_in_primaryExpression1642 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_expression_in_primaryExpression1644 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_75_in_primaryExpression1646 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_booleanLiteral_in_primaryExpression1659 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_PICKRANDOM_in_primaryExpression1664 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000400UL});
    public static readonly BitSet FOLLOW_74_in_primaryExpression1666 = new BitSet(new ulong[]{0x0020000000000000UL,0x0000000000000300UL});
    public static readonly BitSet FOLLOW_objectCategory_in_primaryExpression1668 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_75_in_primaryExpression1670 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ROLL_in_primaryExpression1683 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000400UL});
    public static readonly BitSet FOLLOW_74_in_primaryExpression1685 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_expression_in_primaryExpression1687 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_75_in_primaryExpression1689 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_primaryExpression_in_postfixExpression1714 = new BitSet(new ulong[]{0x0000080000000002UL,0x0000000000800400UL});
    public static readonly BitSet FOLLOW_74_in_postfixExpression1724 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000F08UL});
    public static readonly BitSet FOLLOW_argumentList_in_postfixExpression1728 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_75_in_postfixExpression1730 = new BitSet(new ulong[]{0x0000080000000002UL,0x0000000000800400UL});
    public static readonly BitSet FOLLOW_87_in_postfixExpression1747 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_expression_in_postfixExpression1751 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_88_in_postfixExpression1753 = new BitSet(new ulong[]{0x0000080000000002UL,0x0000000000800400UL});
    public static readonly BitSet FOLLOW_DOT_in_postfixExpression1770 = new BitSet(new ulong[]{0x0166B00000000000UL,0x0000000000000408UL});
    public static readonly BitSet FOLLOW_primaryExpression_in_postfixExpression1774 = new BitSet(new ulong[]{0x0000080000000002UL,0x0000000000800400UL});
    public static readonly BitSet FOLLOW_expression_in_argumentList1803 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_79_in_argumentList1806 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_expression_in_argumentList1808 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_timeEveryExpression_in_timeExpression1833 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_74_in_timeExpression1838 = new BitSet(new ulong[]{0x0000400000000000UL});
    public static readonly BitSet FOLLOW_timeCompExpression_in_timeExpression1840 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_75_in_timeExpression1842 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_EVERY_in_timeEveryExpression1858 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000400UL});
    public static readonly BitSet FOLLOW_74_in_timeEveryExpression1860 = new BitSet(new ulong[]{0x0080000000000000UL});
    public static readonly BitSet FOLLOW_TimeLiteral_in_timeEveryExpression1862 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_75_in_timeEveryExpression1864 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_GAMETIME_in_timeCompExpression1887 = new BitSet(new ulong[]{0x000000FC00000000UL});
    public static readonly BitSet FOLLOW_comparisonOperator_in_timeCompExpression1889 = new BitSet(new ulong[]{0x0080000000000000UL});
    public static readonly BitSet FOLLOW_TimeLiteral_in_timeCompExpression1891 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_booleanLiteral0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_DecimalLiteral_in_numericLiteral1979 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_set_in_identifier0 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_assignmentLeft_in_synpred23_GodPlGrammar1185 = new BitSet(new ulong[]{0x0000000010000000UL});
    public static readonly BitSet FOLLOW_ASSIGN_in_synpred23_GodPlGrammar1187 = new BitSet(new ulong[]{0x0166B40040000000UL,0x0000000000000708UL});
    public static readonly BitSet FOLLOW_orExpression_in_synpred23_GodPlGrammar1189 = new BitSet(new ulong[]{0x0000000000000002UL});

}
}